Which language is more obsolete and useless?

>everything is a tranny

>Fortran
Still used in ancient software that's holding up our infrastructure, but it's not used much anymore
>Lisp
Good language worth learning for fun, but not used in many places

>lisp for fun
There is not even a while loop in LISP. You can't even write 1+1 to get 2. You end up having to reinvent the wheel just to get basic things done
Not fun

Anything you like is plebeian, so the one you like the most.

Fortran's great and still used where it's relevant

both have their use case, but Fortran is actually obsolete

Fortran is definitely not obsolete and Lisp was always useless

>bumping this shit thread
Also Fortran's anything but obsolete, it's used in HPC

fortran is still used fucking everywhere in government/boomer software
lisp was never used anywhere

> Also Fortran's anything but obsolete, it's used in HPC
Mostly in legacy HPC application. Nowadays a distributed/parallel architecture of small procs are used.
But all HPC application is converging to GPGPU, so CUDA (c/c++)

If it's so obsolete why's Nvidia working on a new Fortran compiler? That's not something you do just for shits and giggles

I keep reading about lisp being a language for quantum computing. Can anyone explain why?

*being a good language

closer to pure math i'd imagine
quantum computers are not sequential CPUs

FORTRAN numerical code is everywhere still. About 20% of scipy is FORTRAN. LISP in its various forms (pun intended) is used in many places, not just emacs. E.g. audacity. There are far deader languages.

That sounds like bullshit.
The best argument I can think of is that you basically want to create a new programming language, and Lisp's macros make it easy to half-ass that because you don't have to write a parser and you can embed it inside traditional source code. But I doubt the problems that solves are the important ones.
In the medium term I expect some vaguely inelegant but good-enough Python library where you call functions to define transformations and then call another function to execute those transformations.
In the long term there could be a proper language or language extension designed to make things more convenient.
I don't think there's much room for Lisp.

Because there still are Fortran application to port or maintain.
Fortran is used to "number crunching" application bacause generally people who wrote code for domain specific eng/math/physics problems are not programmers.
But fortran is not even teched anymore in the majority of universities, so new HPC projects are generally in C/C++ (openmp/mpi, CUDA an such)

It isn't, its one of the best languages for HP scientific and numeric computing. People around here are just retarded. Fortran has seen numerous revisions to bring it to modern computing standards and still does what its meant for well.

Whihc is why it is so nice to learn. My mom's friend retired but she can program fluently in FORTRAN, so occasionally she gets hit up by banks and other large corporations and they'll write a check for 140K USD for about 200 hours of work on her end, between meetings, coding, testing, etc. Apparently, companies are fucking too lazy to move to newer languages.

Attached: Christian-Bale-Patrick-Bateman-American-Psycho-President.jpg (675x450, 33.3K)

>But fortran is not even teched anymore in the majority of universities, so new HPC projects are generally in C/C++ (openmp/mpi, CUDA an such)

The fact that you dont know the word "taught" and fat fingered teached which is retard version of taught is concerning if you're planning to appear knowledgeable

Shit b8 m8

>While loop
(defun square-advisor ()
(loop as n = (progn (format t "~&Number: ")
(parse-integer (read-line) :junk-allowed t))
while n
do (format t "~&The square of ~D is ~D.~%" n (* n n))))

Literally from the hyperspec
>You can't even write 1+1 to get 2.
Yes, because LISP doesn't have infix operators, you need to use the function '+' instead.
(+ 1 1)

> taught is concerning if you're planning to appear knowledgeable
It means more that I didn't enroll in shit american universities and that english was not my major

Look at that while loop and tell me with a straight face that LISP is not a horrible and useless language

What os or major app written in Fortran in last 40 year?

That’s just because the only appropriately licensed implementations of those algorithms are in fortrans. No non freetard and non pajeetware developer would use it, they’d just implement it in a C library or even asm.

Not an app but a library, SciPy is 20% Fortran

Dead means no new projects/use cases/installations or no net new. It’s dead. Just because you want to name drop some shit you think only you’re cool enough to have heard of is irrelevant.

Do you know what name dropping is?

so i don't code and i dunno shit when it comes to programming but

can someone please explain to me why there are so many programming langauges? they all do the same thing right? why do people keep trying to reinvent the wheel when it comes to telling a computer what to do? exactly what makes one superior over another, when you still have to learn how that language even operates before you can start utilizing it properly? why doesn't everyone just use C or whatever?

fortran is eternal

>don't like X
>make Y
>someone else likes neither
>makes Z
ad infinitum

GPU Programming in Fortran : Ensuring stability for variable coefficient advection equation solver

youtube.com/watch?v=_zz_Ocl5F4E

Cope. Fortran is eternal. LISP is a pile of useless shit.

> Cope. Fortran is eternal. LISP is a pile of useless shit.
I don't give two shit about both. You can do same that is done in your video in any other language, the problem itself is not very hard theoretically under some circustances obs

But it's pretty lame that you think that a fortran video means something

>I don't give two shit about Fortran and Lisp
Says the guy in a thread about Fortran and Lisp

> if you don't care why commenting???!!!!
You seems lost, this is not the youtube comment section you cinge imbecile

Who's still viewing this thread in current year!!!??!?

Now it's a YouTube comment section

> Now it's a YouTube comment section
Stop it, you are embarassing yourself

no u

Still not at argument. Imagine my surprise.

What are you going on about?

here's one your smooth brain can understand
(defun countdown (num)
(loop while (>= num 0) do
(print num)
(decf num)))

or you could even write one yourself if you want.
(defmacro while (test &body body)
`(do () ((not ,test)) ,@body))

(defun countdown (num)
(while (>= num 0)
(print num)
(decf num)))

Pythonchad here
Is Fortran memory safe?
I don't want manually handle that shit like Chile's.

Here is a better one
while num > 0:
print(num)
num -= 1

Attached: images-3.jpg (616x497, 22.25K)

literally the same
also don't care, while loops are pretty useless in any language anyways

(The (same except (for (these))))

only retards who have never used lisp complain about the parens. you basically stop seeing them after writing a few functions.

What IDE do you use? Emacs+slime? I honestly would like to learn LISP for the abstraction element of being able to create your own language through macros, but I'm having a really hard time establishing a workflow and seeing the point of the whole thing. It seems that everything that can be done through macros can also be done through functions.

>predates C
What do you think, retard?

NTA but I use Emacs. Read Practice Common Lisp and visit /emg/ thread if you need help.
>It seems that everything that can be done through macros can also be done through functions.
Macros don't evaluate the arguments. You can't do, say, (my-macro (some thing like this)) via a function since the part '(some thing like this)' isn't a valid Lisp synatx. You will get an error if you use a function. Macro is a syntax transformation tool. It'll take your code and work on it, that's why you can have a strange, not-so-Lispy syntax like . Macro change that non-Lisp synatx and produce a Lisp code that a Lisp compiler can understand.

yeah emacs+slime is the best ive found for lisp. the parenthesis and indentation are done automatically so you basically dont even think about them.
>seeing the point of the whole thing
I'm just doing it for fun. I know lisp isn't used pretty much anywhere, but I really like the language so I don't really care.
>It seems that everything that can be done through macros can also be done through functions.
they basically are functions but for syntax. you can use them to write your own control structures like the while above, or just get rid of annoying repetition, and from what I understand, the abstraction doesn't make your programs any slower because they're expanded before runtime, so it's like if they weren't there, except they made your code cleaner.
>I honestly would like to learn LISP for the abstraction element of being able to create your own language through macros
a good book that focuses on this is On Lisp, by Paul Graham.
paulgraham.com/onlisp.html
though for getting started, Practical Common Lisp is probably better
gigamonkeys.com/book/

On Lisp is pretty hard for a beginner, that user better read PCL first. On the topic of Lisp book, I like ANSI Common Lisp more than PCL, it's from the writer of On Lisp, too. If he got the basic done, there is also Let Over Lambda that focus on Lisp macro.

>nooooo languages can't evolve they must remain stagnat for eternity

>What do you think
I think I'll stick with python instead of a meme language no one used anymore kek

yeah user should've used recursion instead

None.

Fortran is highly performant in huge matrix crunching, Lisp is highly expressive.

Even if those languages are not used explicitly to write the whole software in, they find themselves in software and in other languages.
Many Fortran routines are called within other software/languages to do data crunching. Many LISP features are implemented in other languages to increase their expressiveness and usability.
So both languages serve their purpose.
LISP is at the highest end of expressiveness and lowest end of performance.
Fortran is at the highest end of performance and lowest end of expressiveness. A typical software will need a compromise of performance (for its calculations) and expressiveness (for its logic), so it will use bits and pieces of both those languages even if it's not immediately obvious.

Fortran - 50 years later, still the king of numerical computation.

arstechnica.com/science/2014/05/scientific-computings-future-can-any-coding-language-top-a-1950s-behemoth/

Oh nononono
we got too cocky C++bros

>Fortran95 supports most C++ or Java features with thenotable exceptions of inheritance and dynamic polymorphism.

LOL! ... and exceptions and a garbage collector and anything for manual memory management(like sizeof) and a preprocessor(its in a preprocessor but not standardized) and templates.

This isn’t to say that optimizedcode isn’t possible in other languages, but you must be much more of an expert to write it.

Somewhat misleading. If you don't know what you are doing, Fortran may be faster. But libraries are less of a thing in Fortran. So if you need a fast hashmap you don't have the choice between 5-10 implementations written by experts. You normally write your own (or you use an array and a linear search because arrays in Fortran are easy.).

Luckily this all doesn't matter because in the end only memory access patterns matter. For simple cases it is enough to just iterate over the first index. For more complex patterns most Fortran programmers just don't know what they are doing.

Also You know the old saying: "comprehensible code is optimizable code"? There is often so much won by some iterator chaining. But Fortran doesn't support that.

Also The compiler may introduce inefficiencies you are not aware of.

We had a case calling into a Fortran 77 routine:
call do_something( matrix_a(index1_start:index1_end, index2_start:index2_end), ... )

Now the compiler had to adhere to the FORTRAN77 ABI which seemingly takes matrices as pointers to continuous memory. So the compiler copied the whole submatrix into a new memory location. Also the compiler (ifort) put the submatrix on the stack. Worked well in all tests. But for large problems we had a stackoverflow. Also debugging Fortran sucks.

Fortran pro: You can learn Fortran in a week .

Fortran con: You work with code of people who have learned Fortran in a week.

>There is not even a while loop in LISP.
>Look at that while loop and tell me with a straight face that LISP is not a horrible and useless language

The other answer () is complicated because they're defining a function, giving parameters, etc. .

Here's a loop in LISP:
(loop (print "hello world"))

How simpler than that can it get? Can print a loop in any other language with fewer words/characters and syntax? Give an example.

It doesn't have an ending condition, though.

You asked for a loop, that's a loop for you.

>libraries are less of a thing in Fortran.
Good thing you can use C libraries

Ok, let me rephrase then, can you write an infinite loop in any other language in a simpler, easier way?

Here's one with set conditions:
(loop for i from 0 to 10
do (print i)) [\code]

Or with while:
(loop for x from 1 to 10
while (< x 5)
do (print x)) [\code]

Lel latex muscle memory fucked my tags but you get the point.

Julia: faster than Fortran, cleaner than Numpy

old.reddit.com/r/programming/comments/o4owvn/julia_faster_than_fortran_cleaner_than_numpy/

it's over.

>posts reddit thread in which the op gets btfo by the first comment
nice desu

I love Julia, but tooling and ecosystem is still too immature.

Only jeet and women use while loop

Fortran is faster than C

>trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies trannies

Attached: 1637792816838.png (800x1000, 18.52K)

Lisp by far.
FORTRAN is still useful in large matrix computation.
Lisp theoretically has never been useful. In reality, it piggybacked off of Emacs and some books, but that's it. People call C a baby duck language, then Lisp is the KING of baby duck languages.
Also, POSIX defines the fort77 compiler that every portable UNIX like OS should have.
Some say this is for backwards compatibility, I say it's because FORTRAN 77 BTFOs most shitlangs.

Also, does nobody notice that the Jewlang has parentheses all over the place.
i i i i i i i ooooo o ooooooo ooooo ooooo
I I I I I I I 8 8 8 8 8 o 8 8
I \ `+' / I 8 8 8 8 8 8
\ `-+-' / 8 8 8 ooooo 8oooo
`-__|__-' 8 8 8 8 8
| 8 o 8 8 o 8 8
------+------ ooooo 8oooooo ooo8ooo ooooo 8

Welcome to GNU CLISP 2.49.93+ (2018-02-18)

Copyright (c) Bruno Haible, Michael Stoll 1992-1993
Copyright (c) Bruno Haible, Marcus Daniels 1994-1997
Copyright (c) Bruno Haible, Pierpaolo Bernardi, Sam Steingold 1998
Copyright (c) Bruno Haible, Sam Steingold 1999-2000
Copyright (c) Sam Steingold, Bruno Haible 2001-2018

Type :h and hit Enter for context help.

C

(((you)))

I know astronomers and they still use Fortran.
JavaScript is a lisp dialect.

Attached: 1640287419498.jpg (604x593, 51.27K)

Lispfags are cultists not achieving anything with it but writing a lot of bullshit. That's why.
archive.is/mnbNo

Isnt clojure a modern lisp that sees regular use?

Depends. Which features do you envy the most?

2/10 made me reply

>There is not even a while loop in LISP.
???
(while TEST BODY...)

Probably introduced at or before Emacs version 1.4.

If TEST yields non-nil, eval BODY... and repeat.
The order of execution is thus TEST, BODY, TEST, BODY and so on
until TEST returns nil.

The value of a ‘while’ form is always nil.

Yes. The parentheses make it better because they allow code to be automatically indented.
Python can't do that, because indentation is significant and the autoformatter can't read your mind.

>lowest end of performance.
Just because you hear this being parroted over and over on the internet doesn't make it true.

Attached: 1637770038546.png (785x495, 112.28K)

Where is the issue?

>can't beat C
Yep, that's my point.