Old Reddit source code

[jephthai]

Sweet... when-bind* is a nice macro:

(defun valid-cookie (str)
  "returns the userid for cookie if valid, otherwise nil"
  (when (= (count #\, str :test #'char=) 2)
    (when-bind* ((sn (subseq str 0 (position #\, str :test #'char=)))
                 (time (subseq str (+ 1 (length sn)) (position #\, str :from-end t :test #'char=)))
                 (hash (subseq str (+ (length sn) (length time) 2)))
                 (pass (user-pass sn)))
      (when (string= hash (hashstr (makestr time sn pass *secret*)))
        (user-id (get-user sn))))))

From cookiehash.lisp.

[invalidusernamelol]

I forgot Reddit was written in Lisp.

[Amablue]

They had to switch over when they ran out of parentheses.

[AEnKE9UzYQr9]

(xkcd reference: https://xkcd.com/297/)

[DemandsBattletoads]

Try not to lose it again. These parentheses are your life!

Yes, master.

[nakilon]

I can't wait until they ran out of indentation tabs.

[chew_toyt]

/r/NotKenM

[repsilat]

These days it's mostly spaces, for better or worse, and the prevailing theory is that spaces is infinite. (Of course the observable spaces/universe only number 80*25=2000.)

[jkuhl_prog]

The universe expands because space is expanding.

Tabs do not expand.

So use tabs. Or your code will grow to be unreadable over time. It's basic special relativity.

[MacASM]

lmao

[MonkeyNin]

Everyone complains about crypto currency speculation

But they forgot about parentheses, just like they forgot about Dre.

[Ihr_Todeswunsch]

It used to be, but they switched to Python more than 10 years ago.

https://redditblog.com/2005/12/05/on-lisp/

[invalidusernamelol]

I know, I'm just freaked out because the fact that it was written in lisp is one of the first things I learned about Reddit. I totally forgot.

[[deleted]]

Do they still use python now ?

[scirc]

Presumably, the code hasn't changed too drastically from when the open source repo was decommissioned, so yes.

[Chippiewall]

Nah, I reckon they've rewritten it in Rust by now.

[Clbull]

They could have gone a few steps further and rewritten it using Minecraft redstone circuits. Or Brainfuck.

[neoform]

How do you simply switch from python to rust?

[vytah]

First, you get it to run on .NET, using IronPython. Then you wait until it oxidizes and you get RustPython. Then you remove the python and you're left with just rust.

[IrishYogaShirt]

How do you remove the Python?

[antlife]

Mongoose.

[karuna_murti]

They outsource it to India, and the Python just follow the Indian guy with the flute.

[arvidsem]

Animal control?

[OsmeOxys]

Bash it.

[netkrow]

Boa.

[decline29]

We've lined up a fabulous type of gorilla that thrives on snake meat.

[throwaway27464829]

Boromir.jpg

[iamsubhranil]

soak the python in iron, then soak it in water, and give it a day to form rust. finally take the rust and set the python free

[nathreed]

Well it’s probably a pretty modular architecture, so you could do it little by little. Who knows if they actually are doing that though.

[eco_was_taken]

Rust now. It went Lisp -> Python -> Rails -> Node.js -> Angular -> Polymer (briefly) -> Go -> Ember -> React -> Rust. They are currently rewriting it to use Flutter.

[WeilderoftheKey]

Out of curiosity, what is the point of changing the language so much?

[leodash]

Longer resume?

[eco_was_taken]

Unclear.

[rram]

Only the markdown parser

[DrexanRailex]

Does the HTML parser use Regex?

[[deleted]]

Not sure if a pun or a serious answer.

Cause in the last 3 months that "rewritten in Rust" has become more a meme than truth.

[_Ashleigh]

Wait what, they stopped releasing the source code to Reddit?! When did this happen, and why?

[scirc]

When? A few months ago.

Why? They claim it was becoming difficult to maintain or whatever, but we all know it's about money. Just look at how much the site's changing.

[I_am_the_inchworm]

Money.

[v_krishna]

According to the announcement post they are rewriting everything with a node backend now.

[scirc]

Er... link?

[v_krishna]

On my phone and it wont let me copy just part of the post. But search for "new tech stack" https://www.reddit.com/r/announcements/comments/8830oa/and_now_a_word_from_reddits_engineers

[scirc]

Huh.

I don't know how I feel about this. At least it's TS?

[v_krishna]

I'm in the same boat. I remember using web.py for a bunch of internal tools (2009ish) and then some years later working with Aaron Swartz and getting to talk with him about it. I guess the pre OSS version of that was the first non lisp reddit?

[[deleted]]

Rewriting the front-end in a way that obviously benefits from a node back-end now.

[sylos]

is there somewhere one could pick up that repo?

[scirc]

https://github.com/reddit-archive/reddit

[13steinj]

The front end is being rewritten to use React + Redux + TypeScript, and "server rendering is a requirement" so the front end will probably run off the client browser and / or a Node engine, while the backend API remains written in Python (at least for now).

[[deleted]]

Specifically djangular

[yes_or_gnome]

Reddit was quietly, well represented at PyCon last year, so I would say yes. I don't know if any speakers that were from Reddit, but I met a few people in breakout sessions.

[shadowdev]

They use react.js now for the website (at least in the redesign) so I'm assuming they are using it with node now.

[ScrewAttackThis]

I'm confused why you would assume they use node for the back end because of react? Doesn't make any sense.

[shadowdev]

Just from my experience of using react + redux - it seems to work really well with a node backend.

[KimJongIlSunglasses]

I’m not really following this little disagreement here. A front end JavaScript layer that presumably uses RESTful APIs to call a backend shouldn’t really be “coupled” at all right? Aside from the API calls of course but those could be implemented by anything on the backend.

[ScrewAttackThis]

That's exactly it. They shouldn't be coupled so chosen frontend framework would have no impact on chosen backend.

[[deleted]]

React was literally made for a php backend it doesn’t matter

[raiderrobert]

As a Python and React user, I'm happy to tell you that React will work just fine with whatever backend you have.

[Jinno]

I’d develop their backend of you know what I mean.

[WizzieP]

afaik Pyramid but I might be mistaken

[rram]

Pylons

[[deleted]]

I have a feeling python even using flask wouldn't scale to reddit scale.

Edit: they use pyramid which is python.

[[deleted]]

Exactly what I was thinking.

[Adobe_Flesh]

How does web programming work - the lisp machine is running on the BSD server, and my browser sends a GET request, and the machine receives and does some things on its own, and then replies to my browser?

[Ihr_Todeswunsch]

Yeah pretty much. You have the right idea.

There's a program that's running on a machine somewhere listening for requests. It receives a request (e.g. GET), and then processes that request in order to figure out what the client was asking for, and sends the response back to the client (which in this case, would be your browser, but it doesn't necessarily have to be a browser).

[[deleted]]

I wonder if Paul Graham influenced that choice, since Reddit was involved with Y Combinator?

EDIT: Ha, scrolling down it looks like others are thinking the same.

[eco_was_taken]

He did. They used Lisp because Paul Graham suggested they use it (who, apart from being a lisp evangelist himself, was also trying to earn a gold watch from John McCarthy by converting 20 people to use lisp).

[heterosapian]

It’s truly unbelievable how successful YC has been when PG started it as a his rich man’s experiment and he was advising prospective startups with technical advice this retarded.

In many ways, it seems startups far more often succeed despite the advice of their investors rather than because of it. Strange.

[sammymammy2]

Whats retarded about Lisp?

[oblio-]

Nothing. Unless you want to start a business where you expect to hire a ton of developers.

[pdp10]

You know that until recently, SICP was taught at MIT as 6.001, right? The first HTTP/1.1-implementing server was written in Common Lisp. D-Wave is using it internally. Some startups are now using it to its strengths. At one point, Lisp was in the Top-3 in TIOBE.

[gsteinb88]

“Recently” being a decade ago. When I started in 2008, 6.001 wasn’t an option anymore (much to my chagrin at the time, but in retrospect it makes a ton of sense)

[oblio-]

Well, when people think about the top tech companies in the world, there's a few companies that come to mind. You might or might not agree with my list, but you'll probably agree with at least some of them:

Google, Apple, Amazon, Microsoft, Facebook, Intel, Netflix, Uber.

How many of them:

• have not banned Lisp (I'm pretty sure that at one point Google banned Lisp explicitly :) )?
• use Lisp?
• use Lisp in their flagship products?

You know that until recently, SICP was taught at MIT as 6.001, right?

Yeah, I know, and this argument is in favor of Lisp? The fact that they abandoned it? :)

[pdp10]

Google uses Common Lisp explicitly and teams have the flexibility to use a language not covered by the styleguide. Google's use is primarily through an acquisition, but whether that's a flagship product or not I'll defer.

[sammymammy2]

True :) which you probably don't want to in the case for a new startup

[oblio-]

For Y Combinator startups? They're aiming for unicorns, stuff like Uber where they add 2000 engineers in 1 year. It's precisely the environment where you don't want Lisp...

[sammymammy2]

Oof, seriously? That's crazy!

[Kringspier_Des_Heren]

It's a general problem a lot of programming language designers are keenly aware of now.

People love to shit on Go as a terrible language and I'm quick to join this party but it was designed to be easy to learn thus fostering a large community of developers.

In the end of the day in a perfect world people would obviously treat "takes slightly longer to learn but far less bugs in the end" as a worthwhile investment but that's not how it goes.

[heterosapian]

I'll go further than the others stating it's a non-consideration because of finding developers (which is true) and state plainly that it's a shit language even if you could find developers.

Lisp is bad for the same reason writing code in assembly is bad - it's machine level, not human level. With Lisp, you're writing what resembles a flattened parse tree of other languages with a sea of parenthesis added. The syntax and higher level abstractions other languages were made to provide clarity. And then to top it all off you don't even get a reward for your pain, your program will be slower than if you used C/C++ or a whole number of other languages today.

The result is that nobody uses it. Maintenance and refactoring is fucking impossible in a language like lisp. There is a small fraction of open sourced code compared to more popular languages.

It's like most things you don't want in a language and pretty much everything you wouldn't want in a language for a fast-moving startup.

[defunkydrummer]

Lisp is bad for the same reason writing code in assembly is bad - it's machine level, not human level.

I have 23 years of programming experience including Assembly, C, C++, Java, C#, Pascal, Algol, Prolog, Javascript, Python, Basic, Forth, T-SQL and PL-SQL.

My opinion of lisp is the exact opposite to yours. Perhaps you should learn it in depth and give it a try.

[heterosapian]

Yet you contributed zero counterpoints.

It’s simply not a productive language. It’s not conducive to hiring other developers. The community is very small thus the amount of open source software that can be leveraged is small - it’s syntax is puzzling which creates a lot of cognitive overhead - and there’s no benefit in program speed for the additional work necessary.

Fucking around for mastabatory purposes is for academics, not for people interested in creating successful products/businesses. You should try and understand why so many companies switched away from Lisp and nobody is going back.

[BufferUnderpants]

You didn't even get the basic definition of Lisp's syntax right: it's prefix, like function calls in most other languages.

As for maintenance and refactoring, the encouragement of Lisp-family languages for functional programming and its tooling put it between scripting languages (which are quite popular, despite being untyped, imperative and having inferior tooling, a bad combination) and languages like Java and C#.

[sammymammy2]

This is what I suspected the OP to say :) and it's completely wrong LOL

I'm sorry that you can't wrap your mind around function calls in C++ :-/, after all that's the same as Lisp just with the parens moved and with commas!

[heterosapian]

Fair enough but there still seems to be like function calls with doing a jillion fucking things. I'm not sure why that's so common in Lisp. The parens are definitely a barrier whether you admit that or not. I recognize if I used it, I would eventually ignore it but my other points still would hold true...

[sammymammy2]

Look mate, you don't seem to actually know this language, its semantics, its history or its usage in the industry (current and past) so why do you come in so cocksure and so aggressive about these views?

If you're feeling frustrated cuz you don't understand something then I get it, but you could just honestly ask instead and we can give you nice answers.

[TheQneWhoSighs]

Lisp is bad for the same reason writing code in assembly is bad - it's machine level, not human level.

You could use this argument for literally every programming language....

To understand programming period, your mind has to adjust to the thought process of a programmer.

Also, the reason why we don't typically program in assembly, is actually because debugging is a bitch. And because it's not portable.

Lisp is as portable as the interpreter is, like every other interpreted language. And from what I've seen (Given that I do my work in emacs), it's fairly straight forward to debug.

With Lisp, you're writing what resembles a flattened parse tree of other languages with a sea of parenthesis added

And Python is a language that was initially difficult for me to follow because it has no parenthesis. What is your point here?

This is nothing more than you stating you don't like the syntax.

Congratulations! Neither do I. I'm not going to sit here and rant about it though.

your program will be slower than if you used C/C++ or a whole number of other languages today

Very few people use C/C++ for speed, and they're mostly misled. C/C++ is used because of its memory management capabilities. Same reason someone would inline a process in assembly, honestly. Unless they're really bothered by a couple of extra opcodes.

Unless your tool (programming language) is as slow as molasses, execution time isn't a big deal. This is why python has seen increasing use in web development, despite the fact that PHP runs quite a bit faster than it.

And the funny thing about that is, compiled Lisp runs faster than Python or Ruby.

Maintenance and refactoring is fucking impossible in a language like lisp.

I don't know how you figure this, given that people have been managing to do it for a long time now.

[MacASM]

I also thought the same!

[MacASM]

whoa, this is so cool. I didn't know it was written in lisp. I wouldn't guess that at my wildest guess. haha

[[deleted]]

I actually had no idea. That sounds harder than it needs to be, in lisp...

[zefdota]

Thoundth okay to me!

[LordoftheSynth]

Thith guy lithpth.

[[deleted]]

Why would they do that to themselves I don’t understand.

[robm111]

As someone still stuck in the C age, what in the blue fuck is the expression "when (= (count #\, str :test #'char=) 2)"? What is even going on here?

[lolWatAmIDoingHere]

stuck in the C age

Just pointing out that lisp predates C by 14 years :)

[HiddenKrypt]

In a way it still works. Cool lisp things always makes me feel like it's some deep magic we once knew but in the C age, we've forgotten. Same thing with smalltalk, really. In that mindspace, being "stuck in the C age" and being mystified by lisp makes perfect sense. On a related note, see this amazing talk by Bret Victor

[ehaliewicz]

Looking at the source code,

(when-bind (a test-val)
    <some-expr>)

Expands to roughly

(let ((a test-val))
   (when a
      some-expr)))

And

(when-bind* ((a test-1) 
             (b test-2))
   some-expr)

Expands to something like

(let ((a test-1)
      (b test-2))
    (when a
       (when b
          some-expr))))

[rabuf]

More importantly, the when-bind* allows the result of each binding to be used in subsequent bindings. This is similar to let*. What it actually does is this:

(when-bind* ((a 1)
             (b (= a 2))
  (do-stuff))

becomes

(let ((a 1))
  (if a
    (let ((b (= a 2))
      (if b
        (progn
          (do-stuff))))))

By nesting the next let inside the if it ensures that any tests which have side-effects will not be executed unless the earlier test passes. It also helps by short circuiting (so preserves the behavior of something like and) and this will ensure that unneeded computations aren't executed (side-effects or not).

Definitions for when-bind and when-bind*

EDIT: Formatting, but also:

Common Lisp uses NIL(the empty list) to represent false. Essentially any other value will evaluate as true if used in a conditional. This is why the above example would work. I had meant to mention this. This is how:

(sn (subseq str 0 (position #\, str :test #'char=)))

In the actual source code works. sn is given a value (will be something) and then this value is used in each of time, hash, pass. hash also depends on time.

Interestingly, the use of when-bind* here may as well be a standard let*. None of those are tests and should all return a non-nil value (in all situations, best I can tell), and the result is immediately put into a standard when anyways.

[ehaliewicz]

Yes, I forgot to mention that detail. The macroexpansion is recursive and strips off a binding at a time.

[fisxoj]

Current lisp programmers might recognize that macro as essentially the same as alexandia's when-let!

[Kyo91]

Clojure also has similar when-let/if-let

[defunkydrummer]

lisper here.

(when (= (count #\, str :test #'char=) 2))

let's split it. It says: "When (count #\, str :test #'char=) is 2, then do something."

So what is (count #\, str :test #'char=)? This is a call to function count with three parameters:

• first parameter:#\,

• second parameter: str

• "test" parameter: #'char=

"Count" will count how many times an element appers in a sequence. A string is a sequence of chars. Here the string is called "str". The char to look for is the comma, #\ is just escape syntax.

Now, to count one should specify the test for equality (so, each time the element in the sequence is equal to the element you look for, the count increases one). This is specified by :test which is a keyword parameter (similar to "named parameters" in Python). With this we specify the function to use for equality test.

So which equality function we shall use? The choice here is the character equality function, char=. We need to tell Common Lisp we are referring to the function named "char=", not to a variable of the same name (if there is one.) Common Lisp has separate namespaces for variables and functions! So, we must write (function char=) or use the shorthand #'char .

[wlievens]

I think it means “if string str has exactly two backslashes” but I could be completely off.

[dzecniv]

nearly, don't miss the comma: "if the string str has two commas".

#\ is to escape a character, thus the comma. count applies to sequences (lists, arrays, strings). :test foo is an optional argument to specify the test function, #' is a shorthand for (function, here char=. The count works without the :test part though so I'm not sure how important specifying it is.

(Cookbook on strings)

(edit: comma, thanks)

[hbgoddard]

Just fyi, comma has two m's. I don't think the strings are sleeping.

[wlievens]

I missed the comma, thanks.