LISP is ugly : programmerhumor

[-] [email protected] 57 points 2 years ago

If your code is that deeply nested, surely something has gone horribly wrong, yes?

[-] [email protected] 14 points 2 years ago

Problem is that Js kind of encourages this being single threaded and using callbacks for anything blocking. To be fair, the new async syntax sugar helps in modern Js, but nesting a bunch of callbacks or promises was basically the way you did stuff for the longest time.

[-] [email protected] 15 points 2 years ago

Yes and no. Any programming language encourages nesting as in the end the computer does nest your code. So it is only normal and predictable that languages would reflect that. BUT! Nest logic can often be inverted and by doing so, reduce how much nesting you need to do.

If (data is not null) {
    If (data has field x) {
         Return data x
    } else return null
} else return null

Can be

If (data is null) return null
If (data hasn't field x) return null
Return data x

[-] [email protected] 0 points 2 years ago

I'm not arguing that avoiding deep nesting is a good idea, or that techniques foe doing that don't exist. I'm just pointing out that Js style programming naturally leads you to nesting things because of the nature of callbacks. Notice how your example isn't using callbacks.

[-] [email protected] 5 points 2 years ago

Yeah and you can void nesting there just as easily and you have the same issues in any other programming language. You just need to create functions. Also JavaScript is not single threaded... you only have access to the dom on one thread, for obvious reasons.

Please explain to me how you do e.g. file downloads without a callback in your favorite language. If you solution involves having the main thread being stuck in a while loop, I am not sure if your complain about nested code can be taken seriously.

[+] [email protected] -7 points 2 years ago

Sure, you end up passing higher order functions around, and my point is that complexity obviously goes up. There's a reason callback hell is a well known thing in Js land. Meanwhile, Js is single threaded from user perspective. The fact that there is a background rendering thread in client side js is completely tangential to the discussion.

Finally, the problem with callbacks is generally seen in server-side Js runtimes. A great example is if you have an HTTP handler that needs to get data from a db. In a language with user accessible threads you just make a db operation synchronously and return the result. In Js, you have to do a callback. The reason you can do the operation synchronously when you have threads is due to the fact that HTTP handler thread can accept a request and then dispatch a new thread to handle it while waiting for other requests.

[-] [email protected] 3 points 2 years ago

It is not really tangential to the discussion. You claimed it is because Js single threaded. Also it is not single threaded from the "users" perspective if you mean the developer. There are workers.

If your issue is asynchronous function calls, just call synchronous functions. You might be stuck in a while loop somewhere but if you prefer that, use it. There are sync functions for everything in Js and/or you can easily create them yourself.

[+] [email protected] -7 points 2 years ago

Js is single threaded from user perspective. You have no access to the threading runtime as a user and cannot spawn a thread in Js to do some background work. Workers are a recent addition, but using them is quite different from what I'm talking about.

And being stuck in a while loop is precisely why people have to use callbacks and why all the APIs are async. This is literally the problem. If you're dealing with any non trivial load, you are forced to use async mechanics.

[-] [email protected] 2 points 2 years ago

And what is the alternative? How do you handle any non trivial load in any other language? Without a second thread or while loop. Because apparently you dislike both. You like it sync for your database -> while loop somewhere, but while loops are bad. But asynchronous is bad because it adds complexity to your code when you use functions to reduce the nesting.

On nodejs, the platform that you talked about earlier, they are literally called worker_threads". So they are different? How? Why can't you use them?

[+] [email protected] -8 points 2 years ago

I literally just explained this to you in a prior comment. Let's say you have a web server that's accepting connections. You have one thread that grabs the connection and spawns a thread from a pool of workers threads to handle it. Then it goes back to listening for connections. This is how things work on platforms like the JVM. The runtime manages the execution of the threads. This is similar to the way the OS handles scheduling processes. When you'd doing async by hand you're basically handrolling your own scheduler each time.

What stops you from using worker threads is lack of ergonomics. Just the fact that each worker has to live in a separate file creates friction. In a sane language you can just do new Thread().start() and you're done. In Js it's a Rube Goldberg machine as always. When you look at at actual code people write in Js, you see async code everywhere. So, maybe you can answer why you think that is, and why people aren't using worker threads to write sync style code they'd write in other languages.

[-] [email protected] 2 points 2 years ago

You seem to misunderstand my points.

And I don't think you want to.

[-] [email protected] 10 points 2 years ago

Code aesthetic: If your code looks like a triangle, you're seriously doing something wrong.

[-] [email protected] 5 points 2 years ago

I prefer a bunch of

if (fucked_up) {return(error_code);}

for checking common errors.

[-] [email protected] 2 points 2 years ago

Yup, never nest.

All the conditions should be checked and returned if they failed as you go through the function with the successful response being the last line.

[-] [email protected] 36 points 2 years ago

I raise you this: https://imgs.xkcd.com/comics/lisp_cycles.png

[-] bdonvr 18 points 2 years ago

Directly linking the file of an XKCD should be illegal

https://xkcd.com/297/

[-] [email protected] 10 points 2 years ago

Linking to images should be illegal

[-] [email protected] 6 points 2 years ago* (last edited 2 years ago)

I'll let Randall Munroe decide that himself, considering the fact that he provides URLs for hotlinking below the comics

[-] bdonvr 7 points 2 years ago

I don't mean the act of embedding or direct linking in general, but in link aggregators these comics are well known for their alt text, which cannot be seen from the direct link.

I think a good practice might be embedding the comic directly in your comment along with a "source" link.

[-] [email protected] 2 points 2 years ago* (last edited 2 years ago)

these comics are well known for their alt text

It's title text, or in web comic circles, hover text. The linked comic's alt is simply Lisp Cycles.

[+] [email protected] 25 points 2 years ago* (last edited 3 days ago)

[deleted]

[-] [email protected] 1 points 2 years ago* (last edited 2 years ago)

Just use this syntax

let myResultObject = getResult() 
let item = match myResultObject {
	Ok(item) => item, 
	Err(error) => {
		return;
	} 
};

[+] [email protected] 2 points 2 years ago* (last edited 3 days ago)

[deleted]

[-] [email protected] 1 points 2 years ago

Oh sorry, I misread what you typed and went on a tangent and just idly typed that in.

One thing you could do for your situation if you're planning on iterating over some array or vector of items is to use the inbuilt iterators and the chaining syntax. It could look like this

let output_array = array.into_iter()
    .map(|single_item| {
        // match here if you want to handle exceptions
    })
    .collect();

The collect also only collects results that are Ok(()) leaving you to match errors specifically within the map.

This chaining syntax also allows you to write code that transverses downwards as you perform each operation, rather than transversing to the right via indentation.

It's not perfect and sometimes it's felt a bit confusing to know exactly what's happening at each stage, particularly if you're trying to debug with something mid way through a chain, but it's prettier than having say 10 levels of nesting due to iterators, matching results, matching options, ect.

[+] [email protected] 1 points 2 years ago* (last edited 3 days ago)

[deleted]

[-] [email protected] 2 points 2 years ago* (last edited 2 years ago)

It feels like maybe this could be a code structure issue, but within your example what about something like this?

fn main(){
    let mut counter = 0;
    let output_array = array.into_iter()
        .map(|single_item| {
            // breaks the map if the array when trying to access an item past 5
            if single_item > 5 {
                break;
            }
        })
        .collect()
        .map(|single_item| {
            // increment a variable outside of this scope that's mutable that can be changed by the previous run
            counter += 1;
            single_item.function(counter);
        })
        .collect();
}

Does that kinda syntax work for your workflow? Maybe it'll require you to either pollute a single map (or similar) with a bunch of checks that you can use to trigger a break though.

Most of the time I've been able to find ways to re-write them in this syntax, but I also think that rusts borrowing system although fantastic for confidence in your code makes refactoring an absolute nightmare so often it's too much of a hassle to rewrite my code with a better syntax.

[-] [email protected] 1 points 2 years ago

the loop or match statement could possibly be extracted to another function, depending on the situation. rustc will most likely inline it so its zero cost

[-] [email protected] 12 points 2 years ago

Back when I was still in school, I ran a few tests on real world LISP and Java (the then dominant language, this was in the late days of Sun Microsystems succes).

Turns out most LISP programs had fewer parentheses then Java had braces, parens and brackets.

[-] [email protected] 0 points 2 years ago

Java follows the paradigm of boilerplate oriented programming.

[-] [email protected] 8 points 2 years ago

If your code looks like this, you seriously need to reconsider your code

[-] [email protected] 6 points 2 years ago

are there any JS fans who argue that it's elegant? i thought the supposed advantage was that it's flexible and universal.

[-] [email protected] 10 points 2 years ago* (last edited 2 years ago)

It's a stockholm syndrome kind of thing.

[-] [email protected] 2 points 2 years ago

Well, universal, anyway.

[-] [email protected] 2 points 2 years ago

Well my Js isn't looking like that and it is really easy not too. But bad people write bad code.

[-] [email protected] -1 points 2 years ago

Weirdly, I've seen plenty of people who appear to genuinely like Js and Ts.

[-] [email protected] 1 points 2 years ago

I learned Lisp at uni and hated it. Thankfully that was long enough ago that I’ve forgotten everything I learned about it.

[-] [email protected] 30 points 2 years ago

I’m sorry to hear you learned nothing.

[-] [email protected] 14 points 2 years ago

Yeah - pure functions and immutable data aren't always the right answer, but appreciating that they're damn good most of the time is a good first step. Writing obvious code that does exactly what it appears to do at first glance and not one thing more? Your colleagues will thank you when they have to work with your stuff.

[-] [email protected] 9 points 2 years ago

And metaprogramming and tail call optimization and and…. At least other languages are starting to catch up with this 60 year old language, by for instance implementing lambda expressions.

Programmer Humor

Rules: