God-tier programming languages, I'll start

Python is shit
FTFY

Javascript

I unironically think Ada should have become mainstream instead of C

>certs count as two years experience.
But actually being good is priceless. Just cuz some recruiter drone wants to see certs doesn't mean they're going to make you suck any less at your job.

Quality bait. That's like saying Haskell doesn't get bugs because its a better language. Show me a bug free language, and I'll show you a language no one's using.

More so that Haskell doesn't get bugs because no one uses it.

>popular languages have more bugs
Much wow

uses ruby

...

am I implying that Ada is bug free?
the compiler is literally a nazi and will fuck you in the ass for pretty much anything that a C compiler wont
also with Ada there would be no need to cuck the developers further with an object oriented expansion thats literally abstract oriented
multi-threading and object orientated programming are really neat in Ada

I'm genuinely disappointed that it's barely used in the industry anymore

COBOL
O
B
O
L

This gets me, everytime.
I have no idea why

ECMAScript

The only one

C#

Cry harder, faggots

INTERCAL

C when you need to be the closest to the metal as you can get without dealing with assembly.
C++ when you are tired of messing with void pointers, structs, want more modern features and a better type system.
Python when you need to make quick and dirty scripts.
Haskell when you want to learn another paradigm, and have a robust garbage collected language with a type system that guarantees your program will behave correctly.
Lisp/Scheme when you want to embed a convenient scripting language in a C program or achieve Satori.

You don't need anything more than that.

...

If he gets hired anyways then who cares

Because they're different languages with different design philosophies. Ada has fewer bugs, C is better at other thing (examples are: pretty much everything else).

...

C++

> taking about programming languages
> people suggesting scripting languages.

Also, C and C++ are the best programming languages. Perl is the best scripting language.

and according to you, how's a scripting language a programming language?

It's not.

missedthepoint.jpg

how's a scripting language a not programming language?**

RUST
no rust

Rust.

...

Right. Even worse

python is for little babby

real man use c

If you want to be successful in this field, you need to be a self-starter, so stop discounting yourself and start working on that quality.

Contrary to popular opinion on Cred Forums I think you should finish your degree. Yes experience trumps all, but it will be way more difficult for you to land jobs without it just because you'll be compared with everyone else at your experience level who has a degree and guess which decision will seem more attractive?

CoffeeScript.js

tell me three things C does better than Ada, except for the enormous documentation and packages avaliable

>money tier
Java

>good tier
C

>mid tier
C++,C#

>useful tier
Python

>shit tier
Haskell

Roblox map creator

Unfortunately he cannot, because his program just segfaulted. :^)

fuck off swadley

...

I like C hashtag and double snake as main programming languages

upvoted

but it's called sepplesepples, not c hashtag

>I crave to learn programming but im not a self starter much

get a fucking grip, there is no "program" to learn how to program. you learn the language, you do some exercises, you get a job and learn a framework and how to solve some problems, you gain experience in working in different frameworks, you develop your own frameworks, you have hobby projects, etc.

>learning some more skill
give me a break. skill is a by-product of learning. learning is experience. experience comes from carefully considering problems and then solving problems.

this poster gets it

probably THE very worst language to learn for any beginner. you will pick up so many bad habits that it will be unreal.

>what do you mean data types? isn't all data the same?
>you mean i absolutely need a semi-colon?
>i keep trying to pass the function but its not letting me!

Actually it's called C plus plus plus plus.

that's what I said

sepples == c++
sepplesepples == c++++

Sepplessepples is C++C++

jPortable, fuck yeah.

Welcome to Cred Forums, bitches

Surprised no one has said Object Pascal yet.

>tfw just started learning java

>using languages where functions arent first class objects

pic not related, I suppose.
BTW CL, Scheme, Haskell are the only acceptable answer. Maybe Rust.

In languages such as lisp (and derivatives) or haskell getting bugs is really hard because of two reasons:
> 1. Functional languages are really restrictive on what you can do and how you do that. They make writing wrong code harder by showing you the road to follow. On the contrary, java/C-family languages give you complete freedom on what to write, and that's why every single company that uses them have to use "conventions" as guidelines to the programmers in order to avoid bullshit. It's like they were placing you in the middle of a desert, but telling you to go in a certain direction.
> 2. Functional languages are usually declarative, which means that you don't tell the computer HOW to do something, but WHAT to do. This makes your code several orders of magnitude shorter, which means less moving parts -> less potential terrain for bugs.

...

D, Go, Rust

ITT: webdevs and NEETS who have never worked on an enterprise level application shit on OOP.

I actually did, that's why the company I'm working for isn't using OOP anymore

same, that shit is pure garbage and slows down everything for no good reason

You just used the wrong platform, senpailam.

functional + OOP > OOP > Functional

multiparadigm > everything else. And, what a coincidence - lisp is multiparadigm...

Java is actually a pleasure to use when you're working with fucking sane code and libraries.

(Lisp (is (retarded)))))))).

I program as a hobby

>programming for a living
>drinking the bloated kool-aid and contributing to the proliferation of shit software
>not being middle management
if you're not literally rob pike you have nothing to brag about

lisp is multiparadigm in the same way assembler is, which is to say not really.

just because you can emulate various abstractions with a bunch of ad-hoc shit doesn't really mean a language has more native paradigms.

{ { So { is { JavaScript
}
}
}
}

Not if you use it correctly.

Class You {
final boolean FAGGOT = true;
}
What the hell does it mean, "not really"? Lisp is a programmable programming language, with its metaprogramming capabilities you can do literally everything. Look at CLOS, for example...
You can not use "correctly" a piece of shit who can not even sum two integers correctly.

Which is never.

You should pick a program and then build that program in the language you want to learn. You start with something simple and move to more complicated things until you've used all the unique and useful features of a language. After that you can move on to another one, but I'd recommend going back and making something in past languages so you don't forget stuff. (I've forgotten Python, of all things, because I didn't do this.)
That's my thinking on it anyway.

LISP is esoteric trash.

More than 3 levels of brackets is a bad programming style.

In this case you could have both conditions in the same if, but what if had more than one sub-condition?

What is Assembly like?

I'm unironically with this guy. C++ and Ada came out around the same time, and c++ was chosen out of idiocy (they thought it was more implementable lel) and teenage rebellious angst.

yea, that's why I said sepplesepples not Sepplessepples

Use functions.

There's two kind of languages. The ones everybody complains about and the ones nobody uses.

Choose wisely, Cred Forums.

Split into separate functions as necessary or consider using something like a predicate list.

That book looks like a M A C I N T O S H P L U S album cover

Not lisp's fault the fact you're not able to read properly. BTW, great example of a real-world application you posted.
Try this:
github.com/ptaoussanis/sentehttps://github.com/ptaoussanis/sente/blob/master/src/taoensso/sente.cljc
1.5k LOC of an entire client+server implementation of a high-performance realtime web framework in pure clojure.
Now show me the equivalent in your favourite language of choice.

>measuring program quality in LOC
When will summer end?

Malbolge

/thread

You forgot the word "incomprehensible".

>1.5k LOC in one file

>gibberish
>great example of real-world app
Functional programming languages confirmed for esoteric programming languages.

>1.5k LOC

Extremely common in web trash.
github.com/SthephanShinkufag/Dollchan-Extension-Tools/blob/25a5f53349057b1216cdcbdc38a92c8991a9622d/Dollchan_Extension_Tools.user.js
Doesn't make it acceptable, mind you.

thanks for ruining my browser

>20k lines
Fucking insane Russians.

I'm not measuring its quality in LOC, but its brevity. You also can't deny that the less code you write the less errors you can commit. That's subjective, it's true, but try to compare the amount of LOC in java used to instantiate and populate a hashmap correctly, and compare it to something like clojure.
reiterating the insult about you not being able to read properly
same
go back to your fizzbuzz in scratch, kiddo, and let the grown-ups speak about serious issues.
github.com/torvalds/linux/blob/master/kernel/power/snapshot.c

Is there such a substory?

ADA caused the first Ariane V launch to crash because of a stupid overflow error.

A Common Lisp program would have just automatically switched to arbitrary precision arithmetic and continued doing what it was supposed to do with a slightly higher performance overhead.

Semicolons were a mistake. It's all trash.

If you're writing legible, respectable code, meant to stand the test of time (and also not be used in fucking web dev), you do not put multiple statements on a line. The only reasons to require punctuation at the end of every line are multiple statements per line and inconsistent newline implementations-- and newlines have been standardized by architecture for ages, and now they're standardized to two different implementations that are mostly accepted on every architecture, and it's trivial to convert them if they're not accepted.
tl;dr: ban this; sick filth

If you're not telling the computer how to do something then what you're dealing with is a scripting language or command (shell) language, not a programming language.
Fucking fight me, you know it's true.

Please stop posting this fud. It crashed because they literally took the specialized os from the IV and just put it in the v without testing it.

en.wikipedia.org/wiki/Programming_language
A programming language is a set of instructions used to communicate with a computer. LISP was the first dynamic functional programming language. It even had pointers, with car and cdr.
It's all about simplifying your communication with a computer, which is the main task of a programming language. If your language of choice is annoying you with repetitive tasks instead of simplifying your communication with the underlying hardware, then it's full of shit and you should choose a better language.
WTF are you even talking about?

...but the only reason why it didn't work was because of single-precision float overflow errors. The physics of the Ariane IV and V control systems were essentially the same apart from a ~2x increase in thrust due to SRB's.

OK there's a third reason: single statements that span multiple lines. That's not as horrible as multiple statements on a line, but it's rarely used and usually avoided.
Again, semicolons bring nothing of significant value to the table.

Enjoy writing your PublicStaticAbstractDogShitFactories while complaining about how gibberish and esoteric sane languages are.

But they didn't test it. They could have written it in brainfuck, it wouldn't have made it brainfuck's fault.

If your language of choice is annoying you with repetitive tasks, you're doing it wrong. You're supposed to write reused code one time and refer to it each time it's used.
>simplifying your communication with the computer
The computer cannot communicate, it's not a person, it's a tool. Programming languages are there to enable you to use that tool.
>LISP
>simplifying anything
kekleberry jam on toast
I was referring more to Haskell anyway you insecure teenager

>posting shitnux code
Congratulations on proving his point, tard.

If you don't understand lisp because you're a fucking java/javascript code monkey it's your personal issue. People who are actually able to program find lisp code really simple.
>the computer cannot communicate
There is such a thing as "one way communication". Also, error/warning/info/debug/ecc. messages can be considered as coming from the computer, so it's not even really one way.
>I was referring to haskell
I don't give a damn what were you referring to because you made a really bold statement which is extending to a whole category of languages - and that's what I was replying to.

Assembly when you hate yourself.

(defun gen-pred (name predicates)
"Gen Pred"
(let (result)
(dolist (p *predicates* result)
(let ((pred (cdr (assoc p predicates))))
(when pred
(destructuring-bind (what . stuff) pred
(flet ((pfun (pred &key (terminate nil))
(destructuring-bind (what . stuff) pred
(if (listp what)
`(defmethod ,p ((self ,name) ,@what)
(declare (ignorable self))
(or (progn ,@stuff)
,(unless terminate
`(call-next-method))))
(with-gen-syms (x)
`(defmethod ,p ((self ,name) ,x)
(declare (ignorable self))
(or (member ,x ,pred)
,(unless terminate
`(call-next-method)))))))))
(push (if (eql what :only)
(pfun stuff :terminate t)
(pfun pred)) result))))))))

This is what you're calling a sane language.

Also, I don't write PublicStaticAbstractDogShitFactories.

I Write TDogShitFactories, you fucktard.

ti-basic

Would it be a good idea to just play with it, just to gain a bit of insight?

you can write unreadable mess in any language, but in C-family/Java langs it's way easier than in others. I can tell that you've seen lisp code two or three times in your life, got scared of the parentheses and ran back to the spaghetti-generating C-like bullshit you usually write, whatever it is.
The point is - what would you understand in your C-like crap after seeing it as much times as you saw lisp code?

>tfw that's the only programming language I know
>no programming job because industrial servers will never run off shitty 9th grade BASIC code

Sure, tell me more about what I know and don't know.

Thus far, you've gotten my experience with functional languages wrong, what kind I usually write wrong (I don't write anything C-like).

I wanna see you keep making mistakes with your wild guesswork, all while still looking smug in the process.

So, the only counterargument you found is the critique of my guessing precision?

Your only arguments were guesswork.

my argument was that it's easier to write unreadable bullcrap in Java/C-family languages than in functional ones. The fact that you're unable to read correctly only confirms my arguments.

>People who are actually able to program find lisp code really simple.
Bitch I know plenty of languages. It's like C (see above) but it goes eight ways bananas with the punctuation. I'm not saying it's hard, I'm saying it's not simple. It's not buttfuck insane like Perl, but nothing is.
>There is such a thing as "one way communication". Also, error/warning/info/debug/ecc. messages can be considered as coming from the computer, so it's not even really one way.
Alright, what's so great about LISP's error and information messages? (Debug messages don't count because every language has a bunch of debuggers and some are better than others.)
>captcha telling me to take comfort, by name
I ain't even mad.

Really? Of all languages you'd choose java with all that bullshit boilerplate? Gtfo.

... so your argument is that Java/C-family languages are easier than functional languages? Were you trying to argue against them? And then even if you were... what does that have to do with me? Like I said, I don't usually write any C-like stuff for a living or as a hobby. The fact that you missed that only confirms my arguments.

>what's so great about LISP's error and information messages
We gotta be a little bit more picky here. Common Lisp is a standard, and there are different implementations of it. For instance, SBCL has really great error reporting - while Clojure, in addition to the standard CL errors sometimes spits out those horrible java stacktraces - and since the creator isn't really happy about it he's fixing it by improving the error reporting and adding specs to the core. And I'm not speaking about other lisps, such as Elisp or Scheme.
So, there isn't "something great" about ALL Lisp's error/info/ecc. messages - it's usually up to the implementor. But, I wanna go safe with this one and start with "they're not gcc bullshit or java stacktraces".
Lisp has literally no syntax, it's a bunch of nested S-expressions. It's like you were using JSON to program, but better. And if you don't like simple parenthesis you can add a syntax you like more - like Clojure dev did for maps/hashmaps/vectors/ecc. Even the syntax in lisp is a matter of preference.
Are you literally retarded? "it's easier to write bad code" does not mean "it's easier", nigger. Try going back to pre-school and learning to read properly.

I just got an apprenticeship in software engineering with Oracle and will be expected to learn and use Java. What am I in for?

It does not mean "it's worse" either, but you just assumed that. Looks like you're also literally retarded and a nigger. Shall we go back to pre-school together?

>except only you'll go because you're a retarded LISP programmer and I actually have a job

Clojure.

It's beautiful, functional, and ridiculously fast for a dynamic language: benchmarksgame.alioth.debian.org/u64q/compare.php?lang=clojure&lang2=python3

It's also incredibly easy to test since everything is immutable, and you get concurrency for free.

How the fuck a higher chance to commit errors isn't making a programming language worse? If you got a gun which shoots straight and another one which is less precise, how the fuck the second one is not worse? Nigga you went full retard.
>says the code monkey who accuses the interlocutor of having no ability to guess and then guesses wrongly afterwards
I actually have a job. And the funniest thing is that I actually program in lisp ad my job. Joke's on you.
this one gets it.

You just moved the goalposts from "writing obfuscated code" to "committing errors".

No surprise there, didn't expect anything else from an increasingly nervous, insecure LISP "programmer" who keeps saying stupidities.

>benchmarksgame.alioth.debian.org
What about a real benchmark?

The code you linked has an if-tornado, which can happen in any language, and it could certainly use some refactoring into smaller functions.

With that said, assuming I can see the rest of the code to see the context, I find it to be quite readable. The python equivalent would be much worse.

The parentheses have the benefit that the code is easily autoindented, and all editors that do this follow the same basic conventions. Parentheses only need to be counted for one-liners, which you could have to do anyway with foo(args) syntax. For multi-line expressions you just rely on the indentation to tell you where the parentheses are and what the nesting is.

Define a "real" benchmark

My college teaches this to freshmen, or freshers as we call them

Looks like I posted this at just the right time... Guess I'll throw in my two cents for Clojure.

We have ancient Java code that has every smell in the book that I inherited, and I use Clojure on a pretty regular basis to incrementally test and develop things.

Even though I am interoping things that are the furthest thing from idiomatic Clojure, it still works pretty great!
Also, I have almost never had any issues with anything that has been written in it.

I say "almost" because the closest it came to introducing any problems was because of some stupid side-effects for some of the Java methods I was interoping, but it was very easy to find out where the problem was.

Pic related is what one of my Clojure scratchpads look like when I am playing with messy Java APIs.

Yes, I do write Clojure on it's own, but this is my most common use of it.

Can't really help you there besides saying "It seems really fast" for the things I use it with.

>What the hell does it mean, "not really"? Lisp is a programmable programming language, with its metaprogramming capabilities you can do literally everything.

metaprogramming and multiparadigm aren't equivalent you dumb fuck.

C, Golang

Yes they are. Lisp macros mean you never have to wait for the language implementer to add some new feature to your language, you can just implement it yourself.

Don't believe me? Take a look at the loop macro in Common Lisp. Take a look at CLOS, which is a beautiful OOP system. It has a lot of features that Java's OO model lacks, like multiple inheritance and multiple dispatch. Yet even though it was a third party library before it was integrated into the main language, it's just as convenient to use as any core feature.

I moved nothing, you did - with your retarded statements. Not even the lisp code you posted was really obfuscated - just written with nonsense-named variables and not documented properly. Again, if you look at the code I posted before you won't see such shit.
Bad code is not defined just by variable naming and documentation, but by logical errors it contains, incorrect memory management (provided a language that makes you do such menial tasks), bad optimization - etc. In Java case it usually suffers from overengineering.
But going back to obfuscated code: Why don't we have a look at a piece of C code you probably run every day?
sprunge.us/OIYM
that shit isn't even the whole function, that is 3 times longer. Do you believe this crap to be readable?
that's what I'm trying to tell that dumbass for about half a hour.
I know. But often, using metaprogramming you can implement a whole new paradigm. That's how AOP got in lisp.

Again, there is a distinction between supporting frameworks with different paradigms and being a multiparadigm language.

When you need to learn non-core APIs or arbitrary patterns/conventions, it's not the standard language you're talking about anymore.

It's the same thing with C, where sufficiently complex projects need to rely on ad-hoc macro soup to hold shit together and then claim to be using "object oriented C" or whatever.

>it wasn't documented properly
>you actually need documentation to understand LISP code
Glad you admitted that.

>sprunge.us/OIYM
>implying I'm not smart enough to use a systemd-free distro
Haha, nice try though!

>I dindu nuffin, you did!
Nope, you clearly said "unreadable mess" , meaning you accepted I meant obfuscated code and not logically erroneous code.

>memory management is a menial task
If you're too dumb to do reference counting, then yes. Anyway, thanks for admitting LISP is a dumbed-down language (on top of being esoteric).

>Java suffers from overengineering
True, but due to many Pajeets. My language, namely, Pascal, in case you haven't figured out yet, does not.

Java also is a very dumbed-down language anyway...

C/Assembly for anything real-time, embedded, or for operating system programming

Python for prototyping, automating pointless tasks, small programs, and for interacting with the OS

Elm for a sane alternative to javascript

Java because your employer is too retarded to use anything else

C# for .Net stuff

C++ so you can use 6 different language features for a hello world program that compiles to 6 megs

Pretty sure that's it.

>Python

Add: data analysis, mapping and plotting.
"Small programs" is very vague.

C macros and Lisp macros have almost nothing to do with each other, apart from sharing a name. C macros are just text manipulation, while Lisp macros are a transformation on the compiler's parse tree.

Lisp macros are much more like C keywords such as if, for, while. They take the code in their body, and change the way that code is mapped to machine code. The difference is, in Lisp you can define your own.

youtube.com/watch?v=yY1FSsUV-8c
So, here is someone live coding
a robot
in scheme
to play music
in front of a live audience.

Because a REPL can change things as they are running, it really lends itself to building bridges as you cross them, or experimenting, or deciding "fuck it" and becoming a programming DJ.

Also, even though that's Scheme, I think Clojure is pretty ballin too

thats pretty accurate and thorough

> Dude, have you seen the Ada standard? It looks pretty cool.
> Lol enjoy your government botnet :^)
> :(:(:(:(

Cobalt

All the financial institutions still use it and fewer people are learning it

>:):):):)
(Sorry, I am a Lisp programmer)

APL

Sorry, I know you're an expert... but do you mean COBOL?

...

>cobalt

You're an idiot.

Java is nice because it's easy.

>LISP is a dumbed-down language
confirmed to never have touched LISP code in his life
>u r dum to do reference counting
it's not about being dumb, it's about easily automatable tasks that the programmer shouldn't worry about
>unreadable mess
I used that term because of your lack of comprehension of lisp code. As said (and as every capable LISP programmer would) that code is perfectly readable - just undocumented.
Ad least there's one thing you got right - a systemd-free distro.

kek

Fortran

>20 thousand lines
So this is the power of russian programmers.

>Are you Egyptian?

Nice.

Holy shit that's normal code with wonky variable names? I might want to retract saying it's not buttfuck insane like Perl.

There are entire languages for mathematical programming. R and Octave are two I'm aware of. I know Python has numpy and scipy for such things but I've never used them so I can't comment.

>God tier (Decent to work with + lots of money)
C#, Java

>Mid tier (Decent to work with + some money)
Python, C

>Low tier (Not much fun to work with, but good money)
C++, JS

>Oh Shit Nigger What Are You Doing tier (No redeemable qualities)
Lisp, Haskell

Again, beginner programmers overusing nested ifs is not language specific. You see it everywhere.

dude, that code is part of systemd.

But uses Erlang too.

Taking a SE class, they call it Advanced OOP. I laughed at Leggable. I suggested a similar interface, Loginable. I hope I can read enough Code Complete to not get into this mess, but our class diagrams are already a mess.

This is what I like about Swift. I'm just waiting for it to become a first class lang on Windows, so that retards can stop sperging about muh appel.

Holy shit, and there actual people in this very board who unironically defend systemd!

This sounds like a fun project. Writing a server for TI-Basic.

Meant to reply to

Only the RedHat marketers, user.

What is so bad about systemd?

>what I like about Swift
get out nigger

Swap C and C++ for accuracy.

Excellent argument there. You sure did convince me.

>unironically thinking C to be anywhere near good for realtime embedded programming
toppest of keks
web.archive.org/web/20090318031253/http://stsc.hill.af.mil/crosstalk/2000/08/mccormick.html

Figwheel + ClojureScript is crazy.

Here is a demo of interactively screwing with a Flappy Bird clone.
youtube.com/watch?v=KZjFVdU8VLI

>Ctrl + F
>No Lua

So folks, would anyone in this thread like to tell me of learning lisp is a meme? My college actually started me off in visual basic then moved to Java. . From all the shit I hear around these threads though, I figure to better understand programming I should pick up C and allegedly lisp is good too. Also tell me your thoughts on Ruby and python please. ;)

acceptable languages everyone should at least be familiar with:
Lisp (Guile[Scheme] preferred, but really any will do)
C (pure plain C, no disgusting extensions or derivatives)
Bash (really doesn't matter so long as you know a shell well)
Haskell (muh true functional)
TeX (and METAFONT if you're super cool and hardcore)
FORTH (muh low level)
Pascal (fuck Go, bring Pascal back)
Lua (superior to python in every way)
IBNIZ (or at least one crazy esoteric language)

That all depends what your goals are.

Lisp has some pretty slick tricks that other languages don't have and will probably give you some new ways to solve some of the things you might find annoying in the likes of Java, however it's not super-useful for job hunting.

As for which Lisp, I would recommend Clojure since it is the fastest, most widely used, and the most functional of Lisp-like languages. Leiningen is slick, tooling for it is top-notch, and the way you can write code in it is arsenal-tier. (Like building a bridge as you are crossing it) It's also surprisingly difficult to write inconsistent code in it, even with threads. You can also use it in Java shops with some pretty great effectiveness, but that's just a bonus.

You could try Common Lisp too, it has some super-powerful features...but it is hard to learn to write good code in it. So, don't get too crazy with it. Also you can use far fewer libraries in it than you can in Clojure, though it has surprisingly good support for a lot of things with quicklisp. CCL or SBCL are the best implementations IMO, though CLISP is very easy to set up, and makes small binaries.

Scheme isn't used for as much real-world stuff as the above two, but it is a minimal language that lets you do some pretty sweet things too. It is also the language of SICP. I don't know as much about it, but a lot of people that use it swear by it and it's derivatives.

Good luck..!

>Ruby vs Python
I prefer Ruby, because you can write cleaner code on the small scale by default. Gems are also usually much higher quality than Python's packages I find.

This shows pretty well how good Gems usually are: asciinema.org/a/7jlodigt8vkldvjjzq40393z3

>C
>Bash
Legacy shit. Still need to be familiar with them for that reason, but it's something to keep in mind, and no new projects should use them.

>Pascal
Deprecated by Ada.

actually I meant it looks like a mess
the indentation and parenthesis are the more sane parts, because they're ordered and clear
for example what the fuck do these do: ` . @ : , &
and eql? is this a fucking language with no equal sign? what is this, 1957?

Many thanks my friends

This is a better video, but it is also longer because it is a talk: youtube.com/watch?v=j-kj2qwJa_E

.LC0:
.string "Hello, World!"
main:
pushq %rbp
movq %rsp, %rbp
movl $.LC0, %edi
call puts
movl $0, %eax
popq %rbp
ret

any books to learn C without the standard libraries? those #includes only get in the way when learning it.

The standard libraries get in the way everytime.

Take a look at qmail's substitute standard libraries (all source files beginning with sub):

cr.yp.to/software/qmail-1.03.tar.gz

this pic makes me lol so hard every time

This video is all kinds of holy-shit.
should watch it.

lol?

The function does some evil stuff where it defines a local function as one of two things, depending on some condition.

` halts evaluation so that you return the code quoted, not the evaluated code, while , @ do various kinds of reenabling evaluation inside a quoted expression to evaluate subexpressions.

These are very rarely seen outside of macros, but can be used in evil hacks like this one though that tends to be discouraged (that entire part should be its own function or macro).

The ( a . b) syntax returns a cons pair, i.e. a two element array containing two pointers to a and b, which is the basic unit you use to build linked list or binary trees. Here it looks like the code is comparing a binary tree as input to a global variable binary tree (asterisks are a naming convention for global variables), and uses the dotted pair form for destructuring/pattern matching.

Colons denote keyword literals, :keyword just returns the keyword :keyword . These are a useful data type unique to Lisp (well, Ruby has them too iirc). They are just literals for themselves, and are usually used as optional flags to various functions or as keys in hashmaps/dictionaries.

The argument &key is used to specify arguments in function declarations and lambdas to specify an optional keyword flag. It's used here as an argument to flet for making a local function definition whose scope is inside the body of flet.

The language has an equal sign function (= a b), but in CL as opposed to scheme/clojure it compares numbers only and gives a type error for non-numeric input. eq/eql/equal/equalp are the functions that do various comparisons between arbitrary elements, by decreasing order of strictness. Clojure cleans it up by instead letting (= a b) be the comparison operator you want in most cases.

thx senpai, i will try.