BTW tinygrad shows that tens of thousands of lines are enough, it's skipping even most of the AMD kernel drivers and talks to the hardware directly.
8,476 karma · joined September 7, 2018
BTW tinygrad shows that tens of thousands of lines are enough, it's skipping even most of the AMD kernel drivers and talks to the hardware directly.
Standards can slow you down, which is fine in a big tech company, but probably not good for building value for your company.
It's better to think more about what may break in your code base that could be emberassing for your company and build integration / othere tests for those important cases.
Otherwise generally simple code is good code, keep building and have fun in life. Lot of those ,,standards'' just overcomplicate things and may hurt your company.
For Python I loved this talk by David Beazley:
https://www.youtube.com/watch?v=MCs5OvhV9S4&t=2510s
He's implementing async/await from coroutines ground up by live coding on the stage
I loved listening to Lex Friedman's imterview with Javier Milei as he was describing how Argentina went to a state of almost hyperinflation by the government helping every poor person with overtacation and overregulation.
I believe that the main reason for wars (and the only way it can be achieved) is money printing (elespecially creating bonds).
Most people from US would never agree in sending money to Ukraine (or at least not everybody) if the amout was explicitly written out on their tax statement. Also I believe the governments shouldn't take money away from people to redistribute how they want (just the minimal amout that they need for keeping up a working society).
Nowdays I'm much more scared than angry about socialist thinking getting us all closer to WW3 though.
https://www.dreamsongs.com/RiseOfWorseIsBetter.html
It doesn't explain _why_ simple implementation is more important than having a simple interface, but it just makes an observation that simple implementation usually wins.
In my experiments simple implementation won for velocity, because quite often I need to change small parts in all the implementation no matter how modular / reusable code I'm trying to write.
As my velocity increases testing becomes more important as well (especially integration testing), as there are more features interacting in a small amount of code.
I think the problem with static typing is that it changes the whole ecosystem too much to be considered just optional, even if it's backwards compatible (like in Python).
Just as an example I'm using lambdas in fasthtml in Python that don't allow type specifications for adding routes and fasthtml keeps on spitting out warnings that I didn't specify the type and doesn't handle variables in lambda functions correctly.
As a Hungarian I see my own country going down economically because Hungarians outside my country got voting rights and benefits because of Orban without reqirements for taxation, and now we are stuck with a dictator.
Of course US has a much more stable system, but the leftist strategy there seems to me like a parallel to what Orban was doing on the right.
In my experience the best way to stop banana republic from happening is to always give power to the party with less power (which was democrat last time, republic this time), as both parties have a danger of trying to accumulate too much power nowdays.
There are lots of small things missing from it (like boolwan support), but it's used as an archival format and backwards compatibility for the archive format is prioritized over new features.
Actually there isn't even 2Y option in Google search, so the author should explain why he chose that time horizon (my guess is just to make a negative article).
Rust started as an experiment of Mozilla team replacing C++ with something that helps them compete with Chrome in developing safe multi-threaded code more efficiently. It took a lot of experiments to get to the current type system, most of which gives real advantages by using affine types, but the compiler is at this point clearly over-engineered for the desired type system (and there are already ideas on how to improve on it). It's still too late to restart, as it looks like it takes 20 years to productionize something like Rust.
As for React I believe it's I believe an over-engineered architecture from the start for most web programming tasks (and for companies / programmers that don't have separate frontend and backend teams), but the low interest rates + AWS/Vercel pushed them on all newcomers (and most programmers are new programmers, as the number of programmers grew exponentially).
HTMX and Rails 8 are experiments in the opposite direction (moving back to the servers, nobuild, noSAAS), but I believe there's lot of space to further simplify the web programming stack.
Reading the original Rise of Worse is better article ( https://www.jwz.org/doc/worse-is-better.html ) gave me a huge appreciation of programming implementariin simplicity, and improved my pace of coding a lot. It shows a real example of why C won over Lisp (a much cleaner interface) 50 years ago.
The funny part is that right now I'm programming in something that may be closer to Lisp (Python), but happy to rewrite parts of it in C in the future when it gets practical.
The amount of features I can add in a small time just because I always pick the smaller implementation surface (while still moving forward) is amazing.
Regarding dependencies: I may want to move to lower level libraries in the future when my project is in a more advanced state, but again they are great as training wheels (lower level would help with customization, but I'm waiting until I _need_ it).
If I pass (int) and (void ) at different places, they will convert to void *, but won't be accepted in the new code.
Still, it would be great to have an implementation where it can be an optional error, and see what it finds.
As OpenAI found its product-market fit, the early visionaries are not needed anymore (although I'm sure the people working there are still amazing)
,,Show to group of people except X'' is manipulative behaviour (instead of kicking out the person from the group, or in this case not sharing publicly what's not public).
On instagram I have seen a lot of these things, for example posts, stories, archived stories all have different very strange behaviours that only people to take the time to understand (more manipulative people) use, which makes people more manipulative in itself.
About meetings: he put some ,,meeting''s in the calendar entry, becuase PMs loved taking his time unnecessarily (he was still available for meetings, just not all the time).
As a high level example Elon Musk talks a lot about his managing style at Starbase in his interviews with Everyday Astronout, and it looks similar: he always goes to the place which is most critical for the product and looks at the technical issues.
I love seeing Victor Taelin experimenting with parallizing these programs (with HVM and other experiments with proof languages), but it's sometimes a bit sad how much time researchers take in making papers about existing things instead of trying to improve the state-of-the art in something that's most probably missing from the current models.
https://www.youtube.com/watch?v=tD5NrevFtbU
I also watched clean code videos and used it in practice, and why it _felt_ right my code size blew up and actually it got harder to understand by other people instead of easier.
Nowdays my main guidelines are getting a balance between less lines of code (while still readable), readable variable names and better performance.
Also I may get hate here for it, but I learned a lot from watching George Hotz programming tinygrad (available on YouTube).
Even though the rules are great, I'm just not sure if it will be good or bad long term for EU.