How is it more powerful? At the end of the day you care about representing AST. Lisp lets you just write code that creates AST. Using text just means that you don't write AST but text that has to be reinterpret as AST later on.
Flex/Bison are compiler-compilers, you write syntax/grammar parsers with them to process text inputs, usually by regex patterns. I played with them writing a printf format parser and a dice roll command parser once but got bored after awhile. BNF to describe your syntax/grammar trees: https://en.wikipedia.org/wiki/Backus–Naur_form?useskin=vector
global program transformations and lisp macros have slightly different uses: a global transformation can do all sorts of crazy restructuring but needs to be half a compiler, and the lisp macro just matches on some bit of ast and turns it into different ast (usually in a bid to avoid boilerplate or enhance performance)
I mean I'm content to be an heretic who prefers Prolog's metaprogramming, but you're on the mark here. My dream language is kinda C with metaprogramming features. C can be so minimal, it's impressive in its own right, like Scheme.
These compiler rules exist because too many developers are incapable of cleaning up up their spaghetti code messes and it kills productivity to have to sort through garbage code that may or may not even be in use.
yeah but im not a jeet,
-Werror=unused-variables
shut the fuck up nigger, some people just like to write a function prototype and then progressively flesh it out, compiling it as they go to check how it's coming along. if the compiler is constantly sperging out at you, it can hinder actually getting work done. if you're really that anal about cleanliness, just install a git hook that ensures the project works with -Werror and also remember the most important rule of enforcing code quality: a determined pajeet can write horrible code no matter how fascistic your linter is
variables in a function don't really influence memory enough to matter unless you're using recursive functions to accumulate stuff on the stack
If you can't comment out your unused code before compiling you may as well be a pajeet. There is nothing about your process that is incompatible with that compile rule. Moreover, creating unused variables is taking up memory for no reason. You may not see how that matters, but those are bad coding habits. This is how you get memory leaks in a language where you manage memory.
This is the flailing around I referred to. You don't actually know what you are doing when you start writing your code. If you wrote your concept in pseudocode beforehand, you could work out which variables you need to use before you start coding.
yeah i keep forgetting how powerful computers are nowadays, but im pretty sure theres a game studio out there where a jeet added an array of 256 4MB structures
ah yes let me comment out and uncomment things so i never have a moment where i don't use a variable
not everybody does everything in exactly the same way as you
how is writing it in pseudocode first better? what happens if you have an unused variable in your pseudocode?
You forgot to attach the image of gigachad.
i'd say its funnier without
It's more if you code in a way that is so frowned upon that your peers need to force your behavior to be rejected by the compiler, you're basically a retard.
Just because not everyone follows best practices doesn't invalidate the best practice. People build houses out of mud and sticks without architecture and it works as a house, but it isn't comparable in quality to a home made of brick according to modern building codes. Programming is no different. That rule exists because your peers have had so many problems with people who code like you that they feel the need to take the option away from you entirely.
You're right, it makes much more sense to write code before you even know what you're doing and before you know you'll even have a use for it.
Your peers don't optimize the unused variables out of their sight. They still have to read them, then eventially realize they're not used after sorting through what the code does. So it costs everyone else but you time and effort instead. That is why this rule exists, your way causes unnecessary problems and time has shown that you fail to clean up after yourself.
Yes, at the time and compute cost of the build failing partway through because you forgot to clean up after yourself. On top of the fact that you are now developing with different compile rules than your CI process. Also you still have to go back and do the work of removing your unused variables, so you actually didn't save any time or effort.
in my entirely unprofessional opinion the middle step of pseudo code was just a thing they taught people in highschool that didnt know programming principles to get acclimated... i can safely say that i havent written any meaningful amount of pseudo code since the required hisghschool projects and i had at least assumed that the professionals were doing the same... i think the most ive ever done is list out features in a notepad/stickynote/whiteboard when collaborating with friends at a hackathon or something. Im not going to knock the practice im sure someone somewhere finds it useful but not me. maybe thats ignorant, maybe thats because i started with highlevel languages so i dont care about memory leaks, but i feel like regardless of the leaks rapid prototyping is a proven method of writing programs. I want to believe your slow methodical principles have merit but i just dont see it.
have you ever stopped to consider that maybe some people use actual code in lieu of pseudocode? or do you never put unused variables in your pseudocode either? i'm not arguing that unused variables are an ok thing to leave in the code even, i'm just saying that people should be able to force the compiler to ignore an unused variable while they are trying to work on something. when they go to commit their code, they should by all means build with all the warnings on and make sure it doesn't have any issues.
Decades ago, Paul Graham posted a little discussion of how ITA Software, the company behind the old airfare site Orbitz used Lisp to implement their software. They had some interesting technical details about memory issues and performance. Some of them sound pretty hamfisted, sorta like you mentioned pre-allocating a bunch of cons cells and handing them out with
cons! .
another big part of this post is just how much you can save by working with the operating system, like how they use
mmap instead of using the usual functions to read things into dynamically allocated structures and creating tons of garbagemalloc and pretty memory-safe if your program is made a certain waylisp isn't really even a programming language it's more like a fundamental truth of the universe that can be made into programming languages
It's building material.