Hey prog made a little webapp in clojure

Check it out: https://github.com/witch-house/pronoun.is
what doy ou think?

found the author: https://www.youtube.com/watch?v=TDDJsKLUh1Y

I'm noticing a disturbing amount of trannies in the lisp/lisp-like Clojure is not a lisp, we get it, "Clojure is not a lisp"-kun community lately. Almost convincing me to switch to Haskell.

Shillin' wit my homies

>>2
hot

*Dys*functional

epic pun XDDDDDDd anyone who isn't doing functional programming is dysfunctional and might as well just die

Trans-functional programming is the future

>>2,5
Reactionary Classist Cis-functional Pigs

>>1
Clojure is not a LISP.

>>8
What prevents Clojure from being a LISP?

>>9
of course it's a lisp, he's just a dickhead trying to sound like some cool wizard elitist. ignore him.

Try these dubs

>>9
Lisp, by definition, cannot be shit. Ergo, Clojure is not a Lisp.

>>13
UNPROVEN PREMISE #1: Lisp, by definition, cannot be shit.
UNPROVEN PREMISE #2: Clojure is shit.

>>13
Proof 1: Lisp
Proof 2: Clojure

QED and go fuck yourself.

>>12
``Platonic Lisp'' doesn't exist. It's a Jewish fraud. They say ``I want money for Lisp'' without specifying whether they mean nonexistent fraudulent Lisp or an actual programming language.

>>13
#1 does not need to be proven. It is a definition. Not being shit is as intrinsic to a Lisp as being unmarried is to being a bachelor.

#2 has been proven many, many times. It is accessible easily, and I do not need to do so here again myself. I do not need to quote an entire copy of Russell's Principia Mathematica just to do basic arithmetic either. For us to get anywhere, I have to be able to trust you to at least make an attempt to stay informed on the subject independently instead of shifting the burden of your education onto me.

>>16

not my job to educate you uwu

I don't need to believe, I just have experience here (my own and my friends). Yes, initial impressions about LISPs were "wtf!?!?! parentheses?! it's unreadable mess!!!", no exceptions (well, probably only me - I was lucky enough to get Common LISP as my first language back in 80s). But, all of them, when forced to deal with this "mess" for few months, got converted to LISP religion and really don't want to switch to other languages now.

Also, Clojure is not your "Common" LISP, it got way more cleaner syntax with approx 1/2 of parentheses compared to CL, carefully crafted by really smart person (Rich Hickey is best thing happened to IT in 21st century) to be as practical as possible and easy to start with.

I'm not doing much of JS work myself last years (mostly some nodejs client bindings to our services and time-to-time client side JS) but I tried both coffee and Clojure scripts in real projects and while I can agree with ALL points about coffee you posted here and 'd like to avoid using it in prod if possible, Clojure Script just worked for me. I even used dommy instead of jQuery and (while it's really tiny ~1KLOC lib) it provided everything needed to solve your typical web 2.0 tasks.

And while it can't be answer for everyone, it still can be answer for quite few developers around here. If you want, I can help you with small follow up "Answer for some of us" article (don't try to contact me through mail though, registration/login doesn't work for me here and I'm forced to use fake email for each comment, skype: theiced should work).

Keep up great work, these posts are really awesome.

>>1
>witch-house/
>pronoun.is
SJWs confirmed as witches

Useless.

>>18
Does Clojure still shit stack traces instead of proper errors?

>>21
Does C still shit segfaults instead of proper errors?

>>22
$ cat test9.c && c test9.c && ./a.out
int
main (void)
{
return *(char *)0;
}

test9.c:4:10: runtime error: load of null pointer of type 'char'
ASAN:DEADLYSIGNAL
=================================================================
==10719==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000 (pc 0x55e3f6809af5 bp 0x7fffdb26ce10 sp 0x7fffdb26ce10 T0)
#0 0x55e3f6809af4 in main /home/sussman/test9.c:4
#1 0x7f10891182b0 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x202b0)
#2 0x55e3f68099c9 in _start (/home/sussman/a.out+0x9c9)

AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV /home/sussman/test9.c:4 in main
==10719==ABORTING

>>23
how does a null pointer have a type of char

>>24
very carefully

>>25
very carefully what

>>22
C is not the standard for Lisps.

>>26
have a type of char.

>>27
C is as much of a Lisp as Clojure is.

>>29
Exactly my point.

>>29
You're right, but not in the way you think. Why is C's ``for'' loop so different from for and do loops in other languages (older and newer than C)? Because the C loop came from Lisp. The loops in other languages are based on counting because they emphasize arrays. If you don't want counting, you use a while or repeat loop instead. C and Lisp emphasize pointers and linked lists. C doesn't have arrays, only pointer arithmetic hacks, and early versions of Lisp didn't have arrays either. This also explains why there is so much overlap between C and Lisp programmers.

>C loop came from Lisp
Shall we pay cultural reparations to Lispers for appropriating their loops?
(loop for x in '(a b c d e)
do (print x) )
Now lets get back to reality:
https://en.wikipedia.org/wiki/C_(programming_language)
"The developers were considering rewriting the system using the B language, Thompson's simplified version of BCPL.[9] However B's inability to take advantage of some of the PDP-11's features, notably byte addressability, led to C. The name of C was chosen simply as the next after B"

https://en.wikipedia.org/wiki/B_(programming_language)#History
Initially Ken Thompson[2] and later Dennis Ritchie[3] developed B basing it mainly on the BCPL language Thompson used in the Multics project. B was essentially the BCPL system stripped of any component Thompson felt he could do without in order to make it fit within the memory capacity of the minicomputers of the time

https://en.wikipedia.org/wiki/BCPL
BCPL was a response to difficulties with its predecessor Combined Programming Language (CPL), which was designed during the early 1960s. Richards created BCPL by "removing those features of the full language which make compilation difficult"

https://en.wikipedia.org/wiki/CPL_(programming_language)
It was heavily influenced by ALGOL 60, but instead of being extremely small, elegant and simple, CPL was intended for a wider application area than scientific calculations and was therefore much more complex and not as elegant as ALGOL 60

https://en.wikipedia.org/wiki/ALGOL_60
ALGOL 60 (short for ALGOrithmic Language 1960) is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them.

https://en.wikipedia.org/wiki/ALGOL_58
First appeared 1958; 59 years ago
Influenced by
FORTRAN, IT, Plankalkül,[1]
Sequentielle Formelübersetzung

https://en.wikipedia.org/wiki/Plankalk%C3%BCl
Plankalkül (German pronunciation: [ˈplaːnkalkyːl], "Plan Calculus") is a programming language designed for engineering purposes by Konrad Zuse between 1942 and 1945. It was the first high-level (non-von Neumann) programming language to be designed for a computer.


https://en.wikipedia.org/wiki/Fortran
First appeared 1957; 60 years ago
Influenced by
Speedcoding
https://en.wikipedia.org/wiki/Speedcoding
First appeared 1953
Typing discipline strong, static, manifest
Influenced by
Assembly language, machine code
https://en.wikipedia.org/wiki/Assembly_language
First appeared 1949; 68 years ago
Assembly languages, and the use of the word assembly, date to the introduction of the stored-program computer. The Electronic Delay Storage Automatic Calculator (EDSAC) had an assembler called initial orders featuring one-letter mnemonics in 1949.
https://en.wikipedia.org/wiki/Electronic_delay_storage_automatic_calculator
Inspired by John von Neumann's seminal First Draft of a Report on the EDVAC,
https://en.wikipedia.org/wiki/First_Draft_of_a_Report_on_the_EDVAC
The First Draft of a Report on the EDVAC (commonly shortened to First Draft) was an incomplete 101-page document written by John von Neumann and distributed on June 30, 1945 by Herman Goldstine, security officer on the classified ENIAC project. It contains the first published description of the logical design of a computer using the stored-program concept, which has controversially come to be known as the von Neumann architecture.
https://en.wikipedia.org/wiki/EDVAC
EDVAC (Electronic Discrete Variable Automatic Computer) was one of the earliest electronic computers. Unlike its predecessor the ENIAC, it was binary rather than decimal, and was a stored-program computer.
https://en.wikipedia.org/wiki/ENIAC
ENIAC (/ˈini.æk/ or /ˈɛni.æk/; Electronic Numerical Integrator and Computer)[1][2] was amongst the earliest electronic general-purpose computers made. It was Turing-complete, digital and able to solve "a large class of numerical problems" through reprogramming.[3][4]

https://en.wikipedia.org/wiki/Lisp_(programming_language)
First appeared 1958; 59 years ago
Typing discipline dynamic, strong
>Influenced by
>IPL
https://en.wikipedia.org/wiki/Information_Processing_Language

Designed by Allen Newell, Cliff Shaw, Herbert A. Simon
Developer Allen Newell, Cliff Shaw, Herbert A. Simon
First appeared 1956
The language includes features intended to help with programs that perform simple problem solving actions such as lists, dynamic memory allocation, data types, recursion, functions as arguments, generators, and cooperative multitasking. IPL invented the concept of list processing, albeit in an assembly-language style.

http://www-formal.stanford.edu/jmc/history/lisp/node2.html

My desire for an algebraic list processing language for artificial intelligence work on the IBM 704 computer arose in the summer of 1956 during the Dartmouth Summer Research Project on Artificial Intelligence which was the first organized study of AI. During this meeting, Newell, Shaw and Simon described IPL 2, a list processing language for Rand Corporation's JOHNNIAC

https://en.wikipedia.org/wiki/JOHNNIAC
The JOHNNIAC was an early computer built by the RAND Corporation (not to be confused with Remington Rand, maker of the contemporaneous UNIVAC I computer) that was based on the von Neumann architecture that had been pioneered on the IAS machine.
https://en.wikipedia.org/wiki/IAS_machine#History
The IAS machine was the first electronic computer to be built at the Institute for Advanced Study (IAS) in Princeton, New Jersey, U.S. It is sometimes called the von Neumann machine, since the paper describing its design was edited by John von Neumann, a mathematics professor at both Princeton University and IAS. The computer was built from late 1945 until 1951 under his direction.[1] The general organization is called Von Neumann architecture, even though it was both conceived and implemented by others.[2]

Lisp is a bastard child of IPL and Fortran
http://www-formal.stanford.edu/jmc/history/lisp/node3.html
The programs to be hand-compiled were written in an informal notation called M-expressions intended to resemble FORTRAN as much as possible. Besides FORTRAN-like assignment statements and go tos, the language allowed conditional expressions and the basic functions of LISP. Allowing recursive function definitions required no new notation from the function definitions allowed in FORTRAN I - only the removal of the restriction - as I recall, unstated in the FORTRAN manual - forbidding recursive definitions. The M-notation also used brackets instead of parentheses to enclose the arguments of functions in order to reserve parentheses for list-structure constants. It was intended to compile from some approximation to the M-notation, but the M-notation was never fully defined, because representing LISP functions by LISP lists became the dominant programming language when the interpreter later became available. A machine readable M-notation would have required redefinition, because the pencil-and-paper M-notation used characters unavailable on the IBM 026 key punch.

The READ and PRINT programs induced a de facto standard external notation for symbolic information, e.g. representing x + 3y + z by (PLUS X (TIMES 3 Y) Z) and by (ALL (X) (OR (P X) (Q X Y))). Any other notation necessarily requires special programming, because standard mathematical notations treat different operators in syntactically different ways. This notation later came to be called ``Cambridge Polish'', because it resembled the prefix notation of Lukasiewicz, and because we noticed that Quine had also used a parenthesized prefix notation.

The erasure problem also had to be considered, and it was clearly unaesthetic to use explicit erasure as did IPL. There were two alternatives. The first was to erase the old contents of a program variable whenever it was updated. Since the car and cdr operations were not to copy structure, merging list structure would occur, and erasure would require a system of reference counts. Since there were only six bits left in a word, and these were in separated parts of the word, reference counts seemed infeasible without a drastic change in the way list structures were represented. (A list handling scheme using reference counts was later used by Collins (1960) on a 48 bit CDC computer).

The most important implementations of LISP proved to be those for the PDP-6 computer and its successor the PDP-10 made by the Digital Equipment Corporation of Maynard, Massachusetts. In fact, the half word instructions and the stack instructions of these machines were developed with LISP's requirements in mind. The early development of LISP at M.I.T. for this line of machines and its subsequent development of INTERLISP (nee BBN LISP) and MACLISP also contributed to making these machines the machines of choice for artificial intelligence research. The IBM 704 LISP was extended to the IBM 7090 and later led to LISPs for the IBM 360 and 370.

McCarthy is also credited with developing an early form of time-sharing. His colleague Lester Earnest told the Los Angeles Times: "The Internet would not have happened nearly as soon as it did except for the fact that John initiated the development of time-sharing systems. We keep inventing new names for time-sharing. It came to be called servers.... Now we call it cloud computing. That is still just time-sharing. John started it.