From 35550adfc7fa427137bed200696af424df8633da Mon Sep 17 00:00:00 2001
From: Robby Zambito <contact@robbyzambito.me>
Date: Fri, 23 Jun 2023 00:26:01 -0400
Subject: Added prefix notation post

---
 .../index.md                                       | 68 ++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 content/posts/languages-that-do-not-use-prefix-notation-are-weird/index.md

(limited to 'content/posts')

diff --git a/content/posts/languages-that-do-not-use-prefix-notation-are-weird/index.md b/content/posts/languages-that-do-not-use-prefix-notation-are-weird/index.md
new file mode 100644
index 0000000..99172b2
--- /dev/null
+++ b/content/posts/languages-that-do-not-use-prefix-notation-are-weird/index.md
@@ -0,0 +1,68 @@
+---
+title: "Languages that do not use prefix notation are weird"
+date: 2023-06-23T00:35:43-04:00
+type: "post"
+draft: false
+tags: [lisp]
+description: "For some reason, prefix notation is often associated with..."
+---
+
+I don't mean that you should avoid such languages, but rather that they are exceedingly uncommon.
+
+For some reason, prefix notation is often associated with Lisp.
+In reality, there are very few languages that do _not_ use prefix notation.
+Off the top of my head, I can only think of Forth, and Postscript.
+
+Consider the following:
+
+```c
+foo(a, b)
+```
+
+What language is this?
+Well, it could be C, C++, Java, Javascript, Python, C#...
+
+Great.
+That looks like a normal procedure call.
+It could be one of many languages, assuming this is not a complete statement (missing a semicolon in some languages).
+
+Now, what if we remove the useless comma:
+
+```c
+foo(a b)
+```
+
+And let's get a little crazy, and move the opening parenthesis to the begining of the expression:
+
+```lisp
+(foo a b)
+```
+
+Now what language do we have?
+Well, it could be Common Lisp, Clojure, Elisp, Scheme...
+Generally, it is some dialect of Lisp.
+
+How did we move the operator in relation to the operands?
+We moved it nowhere.
+
+The only reason that prefix notation is associated with Lisp, is because most other languages have a few inconsistencies.
+Namely, arithmetic operators like `+`, `-`, `*`, and `/`.
+_These_ operators are usually given an _infix_ syntax, and it is placed between its operands: `a + b`.
+In most programming domains, the vast majority of operations are procedure calls - not arithmetic operations.
+
+Lisp does not have this inconsistency.
+The operator is always placed before any operands.
+Expressions like `(+ a b)` may look strange at first, but just consider: `+` is simply the chosen name for the `add` procedure.
+If we use the name `add` instead, we get:
+
+```lisp
+(add a b)
+```
+
+And if we apply the inverse of the previous transformation, we get:
+
+```c
+add(a, b)
+```
+
+Which is really not all that strange :)
\ No newline at end of file
-- 
cgit