Remember that if you don't know Lisp you don't know what a powerful programming language really is

Remember that if you don't know Lisp you don't know what a powerful programming language really is.

daily reminder that if you don't know MIPS Assembly then you're script kiddie trash

But I know it, fag.

And with it i do a lot of QUALITY coding, like IF iterations.

Programming in any form essentially restricts and adjusts your mental
freedom, constraining your ability to think for yourself. Unless you
designed all the architecture building up to what you're programming in,
you're destroying your mental freedom in the most effective way.

Can a MIPS assembly program write another MIPS assembly program?

I get how lisp is supposed to be patrish because "muh aesthetic recursively enumerable sets"

But I've heard it's possible to do self modifying code and shit. is this true?

stallman is a shit programmer, his opinion is irrelevant

This. The Emacs codebase was in an absolutely disgusting state when RMS stopped working on it. Forks like uEmacs (what Linus uses) were created because it was so bad and the new maintainer had to basically rewrite it from scratch. Emacs Lisp is objectively awful even by 1980s Lisp standards as well.

anything another language can write mips can, wont be easy but it is possible

>Forks like uEmacs (what Linus uses)
You sure?

kek uemacs irreversibly btfo

Why Linus is so angry in all these pictures posted on Sup Forums..?

Thats his secret. he's always angry.

Yes. He's been saying that he needs to learn another editor for years but can't be bothered because the Emacs keybindings are too familiar to him now. He made a Google Plus post about it not too long ago.

It's his duty to point out bullshit everywhere he finds it.

You can do self modifying code in nearly anything. Just embed a compiler or interpreter and hand it arbitrary instructions. Fork a process, die, and have the fork write over the launched executable if you want persistence.

(((((((((()))))))))))

Most languages allow for that.

>Most languages allow that
But with Lisp is easy.

Can anyone tell me about clojure?

It's Lisp but on the JVM.

> dynamic typing in 2017

The time for dynamic typing ended like 20 years ago. These days it's just pathetic.

Thanks, might look into it.

It's more Scheme on a JVM

Remember that the true problem of programming is not language but separation of specifications and computations and provability of correctness.

Why should I even consider learning a 50yr old language?

I learned how to translate C to MIPS from an architecture class but anything more than loops would be a real bitch to do

50yr old languages are the most used today. Take COBOL for example.

Remember that if you haven't learned from the teachings of ML and Haskell you're still 50 years behind in development.

Dynamic typing is not acceptable for anything more than scripting.

Java is the most used language today by far. For every single developer pushing out desktop applications in C++ or whatever there are probably 10 corporate drones building horrible business applications.

It's not even acceptable for scripting.

Lol explain why

english is a lot older than 50 years

Why would I want errors caused by dynamic typing in scripts? Modern statically typed languages are basically just as expressive and eliminate a ton of errors I don't want to waste my time on.

Java is 25+ years old.

I never had an error with types

t. scriptkiddie

If you think so, you probably don't know what are the uses for dynamic typing (which are macros).

Statically typed languages can have macros. Scala has macros for instance.

It is from the limitations we impose upon ourselves, or otherwise, true creativity is born.

Wrong, it's slow.
A language can't be powerful unless it's fast.
Think of elegance and expressivity as being like excess food, and speed as being like fitness.
There are skinny languages -- fast, but a pain in the ass to work with. You have to carry them yourself, but they're light, so you can still carry them far.
Then there are muscular languages -- TRUE powerful languages -- fast, but also fast to write. They eat enough to carry their own weight AND they can carry it far.
Lisp, on the other hand, is just obese. Fast to write. Extravagant, elegant. Very good for what it does. Except that what it does is sit around eating more.

common lisp compiled with the SBCL is almost as fast as Java.

>common lisp compiled with the SBCL is almost as fast as Java.
That's literally what I just said: Lisp is slow.

surely there are better functional languages to learn in 2017...

You shouldn't compare low-level languages with high-level ones.

Lisp is not a functional language though

he only seems mildly annoyed

...

If you actually want to get a job learn JS/Java/C#/PHP

Can someone just tell me why MIPS? As opposed to other assembly languages?

is easier than x86/x86_64 assembly because of the restricted instruction set.

So you get the joy of picking through the corpses of 50 years of half implemented libraries that have stopped having support before you were born.

People talk quite a bit of game about lisp, but when you get serious about it you'll realise many of the libraries you need are old.

Biggest problem with lisp is that you can build the world with it, but everyone builds their own little pocket universe from scratch.

it's 2017, we can open files nearly 2MB now

This. If you're really good, you can get north of 150k if you're good with architecture.

...

>being so retarded you don't know how to use case
>disgusting non-functional code too
>literally so inbred you literally copy-paste the same function over and over again, i.e. conditioning literally at the wrong place
You don't know it.

>It's his duty to spout bullshit everywhere he finds himself
FTFY

>what are legacy systems

lisp is gar age lol, that's why nobody uses it

Good idea but the entire standard libary should be done from scratch with names and behavior that follow the "least surprise" principle. Shit like cadaadadr shouldn't ever be allowed. And DSLs are considered harmful.

Did some lisp in college with all the other undgrads. The language is neato for what it does and it is surprisingly extensible at its base. It really requires a different mindset to become proficient compared to most other languages and that can be really off putting.

MIPS assembly is literally taught in school. If you don't have an 800,000 line program in Chef you might as well be programming in Scratch.

>modern_developers.jpg

>le 'nostalgia for a time period that I was never a part of' meme
kill yourself

>my_code_is_write_only

Thanks for insight pajeet. You kindly doing the needful.

But I am so creative I circumvent those limitations and create new ones

Sometimes applying limitations inspires creativity and improves productivity.

I'm going to make an analogy to vidya. From the late 90s until ~2005, many games (especially FPSs) came with level editors. These were somewhat complex beasts, but without unlimited power. Levels had to be composed of BSP brushes, adding and subtracting mainly-rectangular shapes to create a 3D space and then applying textures in a direct way (auto UVs).

Individuals could and did create entire interesting levels by themselves, and released them.

Doing the same for a modern game engine, if it's even possible, is a mammoth task. They are optimised for flexibility but at the cost of requiring a full dev team and professional content creation pipeline to create anything non-trivial.

I think the same applies to programming- if you're designing a system from the ground up and given the task of architecting everything, you will spend a long time on design decisions, support libraries, tooling, and boilerplate. Given an established system and an IDE, you can be productive immediately.

>lisp is functional

it's what they were taught in undergrad.

>common lisp compiled with the SBCL is almost as fast as Java.

This. It's actually known to be almost as fast as C, sometimes faster.

what do you mean by this?

nigga he's disagreeing with you

Ok so Lisp is a powerful language. I'm curious to know what it is lacking that makes it not mainstream

Are you sure what's changing isn't our expectations?

If you made a Quake 1 level in 1997, I don't know that it would be harder to replicate the same level for a modern game in 2017.

However, instead of looking 80% like a pro level like it did in '97, it would look like shit because the pro level has moved so much.

This is a good point- part of it is probably the demotivating factor of knowing that your levels can no longer look comparable to official ones.

But if you'll allow me to nitpick,
>I don't know that it would be harder to replicate the same level for a modern game
That's not really correct- the CSG editing tools are generally no longer present, so you need to be able to use 3D modelling tools to make anything at all.

>>>/reddit/

A few things:
- No good framework for static typing. For large programs, static typing is downright mandatory. At best, some common lisp implementations have type warnings, and verbose statements have to be made to enable them. This is not acceptable.
- No good libraries, period. Self-explanatory.
Honestly that's pretty much it. The rest is bikeshedding (muh syntax is unfamiliar and the likes).

I'm really sorry but I can't write business applications using assembly

He's precisely as irritated as every other good programmer on the planet, it's just he's the core designer and contributor to the linux kernel and thus isnt filtered behind 30 walls of HR and can speak his fucking mind.

>No good libraries, period.
How does Clojure fare, can't it call Java?

Yup, but clojure is not Lisp

No good libraries is an issue. But I don't think that's really the problem.

I suspect the main problem is literally simply that the language is too powerful. Put another way, it gives designers too much room for creativity and freedom of expression.

It's a great program for personal use, but it's terrible for teams because not everyone is forced to work at a manageable, common level(or put a lot of work into making something work the way they want it to).

It'd be like, Joe and Bob are working on a team. One day, Bob comes in and find Joe has written new features, but has decided that new variables should be written with Korean letters as names and the normal order of math operations should be reversed. Also, there are 10 new functions which compile differently based on the results of functions evaluated at compile time, with special compile-time scopes.

Bob is probably going to be taking a few days off to figure out how the fuck Joe's program works. This kind of stuff is possible in other languages but the level of work required to obtain it(without stupid "hacks" like re-writing the code file before compiling) is much higher, so most design is limited to a linear, more easily manageable flow simply by the nature of the language.

Does this make the languages less powerful than LISP? Yes, but it also serves to bring people down closer to a common level. For personal projects LISP is extremely powerful, but for these reasons(although I'm only theorizing) LISP is not the language that's going to land you a job. Add onto that the stigma it got from the developments of the AI boom following and AI winter and you've got the reasons why LISP gets a bad rap in some contexts, despite being arguably the "strongest" language.

tl;dr it gives too much syntactic and non-linear freedom too easily, which is a liability when working in a team. the AI winter nonsense didn't help.

Adding to this a little, the freedom LISP gives means that in a team, there is a necessity for the team as a whole to be intelligent enough to organize its own design philosophy well, AND for every individual to be intelligent enough not only to understand the resulting code but to follow the design principles, and responsible enough to not go off and do anything crazy.

Unfortunately as you can probably learn from listening to many professional programmers bitch about their work environments, these conditions aren't common. So part of LISP being not mainstream despite its power is that it's simply not good for business/teams because it requires high coordination and intelligence to keep the language itself maintained(down to the level of the individual), and furthermore in day-to-day application where its power isn't needed it would only serve to complicate things.

Trying to summarize, LISP is never going to become "mainstream" because it gives a level of freedom which can run counter to teamwork, and dumb people exist. If Ted writes code Bob is too stupid to comprehend Bob can no longer contribute, and this can happen more easily in LISP than other languages because LISP makes no attempt to restrain the user.

In my opinion, Lisp code is super easy to document and to maintain. The real problem behind this language is simply the fact that it's too different from the others.

\thread

(defun thread (&rest shitposts))

>using a tool to paint ruins your ability to think creativity