Comments by "Mikko Rantalainen" (@MikkoRantalainen) on "ThePrimeTime" channel.

  1. Most JS frontend developers use over 1 MB of JS code to show a simple dialog. This developer implemented full gaming engine in 13 KB.
    225
  2. I think a lot of the Rust lifetime unreadability goes away if you start giving more descriptive lifetimes but 'a and 'b. For example, 'request, 'fileopen etc. Then your error messages will make more sense when it's obvious what the lifetime means for logic.
    49
  3. 12:10 Writing single-task application was considered too hard so interns wrote and executed custom SQL queries against production database??? How? Why?
    39
  4. I think being a senior developer is not about already knowing it all. It's more about being able to consider long term side-effects of decisions you make for the project. Sometimes a quick hack is all you need, sometimes a quick hack now would bite your ass in the future and typically it's the senior developer that can tell the difference.
    34
  5. Modern image generators can do supriringly well even with a bit weird prompts such as "Minotaur centaur with unicorn horn in the head, steampunk style, award winning photograph" or "Minotaur centaur with unicorn horn in the head, transformers style, arc reactor, award winning photograph". Even "A transformers robot that looks like minotaur centaur, award winning photograph, dramatic lighting" outputs acceptable results. However, ask it for "a photograph of Boeing 737 MAX with cockpit windows replaced with cameras" and it will totally fail. The latter case has way less possible implementations and this exactness makes it to fail.
    33
  6. The best explanation about Apache 2 license is "Like BSD 2-clause license + patent clause, but well written." I used to license my code as GPL v2+ but I've later changed to MIT or Apache 2.0 licenses later. And yes, I'm one of the weird ones that actually reads and tries to understand the licenses.
    24
  7. And the S in LLM stands for security.
    22
  8. If you have competent attacker, they will just DDoS your network win SYN flood from distributed bot net and there's nothing you can do about it because your application firewall doesn't even see a proper connection to start to filter. The idea is to have so much traffic that your network connection is totally filled up. Cloudflare is the only cheap solution to that but that requires giving Cloudflare ability to read all your traffic.
    18
  9. 15:55 The idea that DOM is so slow that you can run javascript to emulate the tasks that DOM is supposed to do in C++ code is a long term plan sounds a bit weird idea to me. Unsurprisingly the browser native implementation of DOM has gotten much better during years.
    17
  10. 11:00 I think in addition to using only 100% LLM generated data for the next generation, they also overtrained the model to generate previous generation output as closely as possible. (They explain that they compared output string to previous generation output. I think they should have asked for similar meaning, which could have been checked by some other LLM. When you train for identical strings, you'll be overtrain / overfit the network for use which is known to be detrimental for the output quality.)
    16
  11. 4:32 Finally somebody explains how The Berne Convention actually works! This makes so much more sense for the resulting copyright laws than the traditional explanation.
    11
  12. 21:30 This sounds like "we only do unit testing with mock data" – how about doing some integration tests, too, with real Windows installs, too, before distributing the files automatically to nearly 10 million systems? Like run the actual update on real hardware running Windows, restart the Windows system and then check if the booted system can detect the attacks you're trying to guard against? That kind of testing would have shown that "oops, the system didn't come up after restart".
    11
  13. And while you're running the code as modules, add artificial sleep(2ms) to every call to the module to be prepared for the extra latency you'll suffer when you convert that module to microservice. If you feel that your system is getting too slow, remove that artificial sleep call but understand that you cannot ever change that part as microservice either because the latency would be too bad.
    10
  14. 33:33 One programming language worth learning enough to fully grasp its design-by-contract feature is Eiffel. I think that language has even less real world use than Haskell but the design-by-contract feature is obviously useful in any language, even though Eiffel is the only language with full native support for it. Other languages use assert()s to emulate the missing feature.
    10
  15. 5:25 Literally 10x faster with LLM is obviously easily obtainable if you have bad enough skill issues. I think even 100x might be possible if your own skills are bad enough.
    9
  16. Using constexpr everywhere is otherwise nice but you cannot have any input, which reduces the usability a little bit.
    8
  17. 23:45 I really hate when a publication renders graphs next to each other and clip the vertical axis differently for every graph. For example, the Retrieval graph for LAION-400M should practically render three nearly horizontal lines instead of strong linear correlation if you used vertical scale that went from zero to one instead of 0.73 to 0.87.
    7
  18. Bob Ross would have been proud of CrowdStrike software: it only worked as a result of happy accident. Ever. And it was a small miracle the whole system collapsed only now. With the engineering standards that they are demonstrating in this report, I'd have expected to see major issues years ago.
    7
  19. I think one shouldn't create new systems language that is not safe by default. However, doing intentional exceptions should be easier than with Rust. Rust basically only has unsafe block but what we would really need is ability to declare that some specific data structure fullfills some restriction that allows it to be accessed cross-threads in some way that wouldn't be normally possible. That way the Rust compiler (or any other language we're talking about) could be in safe mode at all times but follow the explicit extra assumptions you've declared. Right now Rust only supports totally safe or "trust me bro, I know what I'm doing" modes.
    7
  20. Just like an experienced C developer saying "manual memory management and pointers are actually very simple".
    6
  21. 5:45 I interpret Linus's opinion here as "LLM can be a great code linter but you should assume its output as opinion about the code and then decide by yourself if you want to actually change the code". Though this obviously assumes that the developer skill issues are more about the accuracy of the implementation instead of overall algorithm or mis-understanding data structures or thread locking.
    6
  22. GC is basically a trick where you pretend that your computer has infinite memory and you keep doing new allocations and GC hopefully can figure out stuff that is no longer referenced anywhere and can be released. If your system has really lot memory, a good GC never does anything because NOP implementation can already pretend having infinite memory. The problem is that GC systems typically have practical 5–10x overhead meaning if your application really required 500 MB RAM, it requires 2500–5000 MB when executed with GC. However, if your developer cost is 5–10x less with GC, it makes sense if you pay for all the hardware. And if the customers pay for the hardware, GC is pretty much always a win unless you're seriously RAM limited (e.g. gaming). GC can be tweaked to run with very small RAM usage overhead but then it will use lots of CPU to continuously go through the memory and look for stuff to free.
    6
  23. 39:30 I read this as "If Microsoft had provided us easy-to-use API for this stuff, we wouldn't have needed to create our own kernel driver". Yeah, but you did decide to write your own kernel driver but did half-assed job on it.
    6
  24. And the more modern version goes like this: there are only three hard things in computer science: naming things, cache invaparalleldation and off by one errors.execution
    6
  25. 20 µs is quite important time even for web programming if you're computing JSON response that consist of 500 elements. If you take 20 µs per element, it will be 10 ms for the whole list already.
    5
  26. 7:27 "I am always a rebase guy because I properly know how to use use git." Amen, brother!
    5
  27. 28:00 I guess it depends on your definition of "cold start". I assumed it would have meant that every database has all the important bits in the filesystem cache in any situation. If it actually meant "not having to boot a new VM", sure, that's much much easier thing to accomplish if you don't need VM level separation for security purposes. And considering the amount of hardware security bugs related to VM escape vulnerabilities, I would rather bet on well written server software instead of VM containment.
    5
  28. It's pretty obvious that whoever did this benchmark didn't bother to write the best code for each language. PHP has a function called levenshtein() in the default install which is implemented in C. Should be pretty fast, right? If you re-implement that poorly in PHP, obviously the performance is going to suck.
    5
  29.  @MrHamof  It's more like debug code has more stuff in RAM and off-by-one errors have higher probability of overwriting some debug information instead of real data so buggy code doesn't crash the system equally often. Of course, when your system is memory bandwidth limited in the first place, having to use more RAM to keep debug stuff in the RAM is not a great plan for high performance.
    4
  30. 43:10 The days or even weeks I'm spending in state "I'm thinking more than writing the code" is when there are no good solutions given the existing infrastructure and the task at hand. Only multiple options to proceed but each with various obvious con-sides. In practice, in that case "thinking" is about going through existing programs (searching for something similar and looking for results with pros and cons any given solution had), implementations (typically reading code of some open source libraries to understand how they handle the problematic edge cases), research papers, writing some test code etc. That's the "research" in R&D. I have trouble imagining a coder that just sits there meditating and coming up with a good solution they will finally write. Some call this maintaining a legacy system but I think it also covers making any complex changes to any big system, not matter how old or new the code is. Legacy systems are just typically bigger than newly created (toy?) projects. And you get old hairy legacy systems as a result if you repeatedly try to skip the thinking and research part and always go for the most simple solution you can think of without thinking about the con-sides. Basically: how much technical debt your next change is creating to the whole system? If you ignore the debt, making changes is faster but it will bite your ass later for sure. On the other hand, you don't want to waste time trying to create perfect solution either because perfect is enemy of good and it requires insane amounts of time to create perfect solutions.
    4
  31. I'm a software developer but when I'm fixing my car, I sure hate rust.
    4
  32. 8:40 I think this still doesn't explain why the update file was full of zeros. I would understand if it contained some actual data but didn't match the expected runtime parser.
    4
  33. Skill issue makes it 25% of your time. It seems that Casey has some kind of mental block which prevents him from even trying to understand Git well enough. On principle, not because of mental issues.
    3
  34. Loved the prompt engineering tips in this video!
    3
  35. 47:30 I think "Would you switch to typescript if introducing this new syntax would allow it to run 100x faster than javascript?" would be even closer analogy. And even I would stop writing vanilla JavaScript if TypeScript were actually faster.
    3
  36. 48:59 In the team where I work, when you do code review and accept the code, you'll be the one fixing the bugs when the original author is on the holiday. That results in automatic "nope" whenever some piece of code cannot be understood. A code like the crap in this m4-file is clearly either an exploit or totally unmaintainable. Either way, it doesn't get to live in the official master branch. I'm not sure if I'm just old enough but the bash scripts seemed easy to understand compared to the m4-stuff.
    3
  37. I've been writing software professionally for 20+ years and I see future of software development that I'll be competing in communicating with normal people about their needs for new software. Once normal people feel that they can more successfully explain their ideas to AI than to me, then AI will take my job. Until then, I see future software development as I communicate with normal people and I then communicate with the AI and fix possible mistakes that future AI still makes. Right now, the AI can do pretty little compared to my output but I'm fully expecting future AI systems will be smarter and smarter every year and at some point the future AI will produce better code for a clearly specified requirement spec. I'm still not sure how long it will take until AI can communicate with normal people so well that AI can get the requirements directly from the normal people so they can cut me off the chain. I would have probably 20+ years until retirement and I have trouble seeing the future where my current work cannot be done with high level AGI which some will call ASI. And I can only hope that we switch to universal basic income (UBI) or something similar until the society collapses because so many people will be miserable otherwise.
    3
  38. I, too, like C exactly the same way I think about mechanical watches: with enough skills you can create masterful results but even a small mistake will destroy the value of the whole thing. For practical systems programming, I still think Rust is the least bad option.
    3
  39. I 100% agree that libraries (or rather APIs of any kind, internal or external) should have clear comments about the things that API promises. If you have only the code, you can never know if the library failing with some input is by design or implementation mistake in the library code. If you do class based object oriented programming, my rule is that all public methods must have comment before them to explain the API for all external callers. Don't like writing those comments? Make the method private and you don't need to write a comment! And use whatever comment syntax that allows IDE tools to show documentation to the callers. E.g. JavaDoc in case on Java code, PhpDoc in case of PHP code etc.
    3
  40.  @TurtleKwitty  I agree that most Rust code uses just 'a but I fail to see why anybody considers it like the best possible implementation.
    3
  41.  @TurtleKwitty  Do you understand why lifetime annotations are used in Rust?
    3
  42. 9:50 As I see it, when AGI is invented (my guess is still around year 2030), there's no need to have average humans do verification of generated code nor write tests or be prepared to generate hot fixes when something fails in production. AGI can do all that just fine. It will take years more until the AGI is better at everything than the best human at the same task. But most companies employ a lot of average people and replacing those with average level AGI is going to be pretty simple. And it will happen fast once AGI is cheaper to use than humans. For a couple of years, many people will feel that they can compete with AGI if they cut their salary. And that may allow having higher standard of living than the people that will not cut their salary on principle and will end up without a job as a result. But AI will get cheaper every year and it will not be long until AGI will take all jobs that a worker with average skill for that field can do.
    3
  43. The whole article smells like "our problems are really caused by React but we blame HTMX instead".
    3
  44. I totally agree that you shouldn't abstract before actually feeling the need for it. Say you abstract your invoice printing from the start to support printing to JSON and stdout. However, when the boss then says you have to support HTML, too, and by the way, HTML needs company header, you have to redo every abstraction you already did for the printing stuff so support injecting the extra information to pass the header without using hardcoded header or global configuration values. And the same thing for every other extra dependency what your future data print needs might be. I know I've done lots of unnecessary abstractions during my career and it's not an accident such thing is called astronaut architechture: you try to guess what kind of interfaces you might need if this specific feature would be used by NASA during the Mars mission. And since you cannot possibly guess that correctly, you'll always miss something and have something extra that even the Mars mission is not going to need.
    2
  45. 13:00 I think you're just have too high expectations about human lawyers. GPT-4 (not the "omni" version) already did better than 90% of all the human law students in bar exam last year. I'm fully expecting GPT-4o to be smarter and improve that number. For best results, you should use AI to suggest a solution and then have a pro human lawyer to verify it before doing any radical decisions. But if you cannot affort both, GPT-4 is highly probably already better than a baseline human lawyer. And I know GPT-4 isn't that good so my only conclusion is that humans do A LOT of mistakes.
    2
  46. I see archived backups of backups mandatory for any important service. However, the thing that most companies fail to understand is to estimate the recovery time in worst case. If the recovery time is too long compared to the losses of income during the recovery process, the company may still die for it and then the theoretical possibility of recovering data perfectly no longer matters in reality. The big question is should to do regular test recoveries from archives? With my current work, we only regularly test recovery from main backup, not backup of backup.
    2
  47. 9:52 The colors are used to express that a single line of code can be split over multiple locations in assembly. For example, the for() statement in C code is split on lines 95,96,114,115,116 and all these lines have identical color to make it easier to notice this. The colors appear purely random so green doesn't mean something else than red.
    2
  48. I agree I think I used winamp until year 2001 or so when they "improved" it and it got really bad. Probably related to AOL ownership.
    2
  49. 19:36 "I think the proper mentality to have as a programmer is, everything is horshit, it's all inconvenient. And either you deal with the things given to you, or you write it yourself and you deal with that." Amen!
    2
  50.  @64jcl  I try to use vanilla JS code, too, but I know that I belong to really small minority.
    2
  51. If I remember correctly floating point operation was a single FPU instruction but it took A LOT of CPU clocks to complete. Quake (the first version) did one FPU division operation at the same time as CPU was doing 16 multiplications and 16 additions. 486 was way slower to compute the floating point division which is why it was really slow to render Quake graphics. Square root is even slower operation than division in FPU. One could argue that original Quake was running on two cores on a single core CPU (the CPU and FPU could compute things at parallel on Pentium CPU). The fast square root algorithm does division + square root using one bit bitshift operation, three multiplications and do additions (identical to substraction with the sign reversed) so it was about 5 times faster than a single division on FPU, never mind the square root operation.
    2
  52. Asahi Lina wrote a thread on X 2023-08-31 about Linux kernel APIs being too inaccurate and how it affected her GPU driver which is written in Rust. Her driver could support runtime loading and unloading but the kernel C level APIs have way too many edge cases undefined and when she contacted the authors of C level API she received "just copy what amdgpu driver is doing" instead of having a clear definitions of the expected behavior. And it turns out that the amdgpu driver doesn't even do the thing she was asking about! Update: I see you reviewed part of this thing near 50:00.
    2
  53. 0:44 I think the argument for "must license for AI input data or copyright infringement" is a weak one because you could just purchase a DVD from Ebay can call it a day. Copyright doesn't give copyright holder to say what a given legally licensed copy can be used for, other than distributing additional copies (which is prevented by copyright law). Specifically, copyright law doesn't grant copyright holder right to dictate how the copy can be used – and this is further demonstrated all the EULAs that end users must additionally accept if additional restrictions are required. If copyright holder could dictate such restrictions, we wouldn't have "I Agree" buttons anywhere.
    2
  54. 14:20 The argument "I could look that up" doesn't make any sense to me. I could write a book about fly-fishing in Japanese, even though I know nothing about fly-fishing or Japanese. I would just need to look that up. Not having to look up stuff means I'm more productive in my work!
    2
  55. Self-driving cars are especially hard because you need low latency loop. I think you could already do LLM based implementation for self-driving car if you accept is goes about 1 mile per hour to give it enough time to evaluate everything needed and to come up with suitable option. And even then it might need a supercomputer running a single car.
    2
  56.  @BittermanAndy  I know that LLMs (with typical text based training) have nothing to do with self-driving cars. However, the algorithm itself is generic enough to train from example driving by humans if you give it enough computing resources. Is it a good algorithm for such a solution? No. But it would be good enough. Human brain works by having a HUGE biological counterpart to LLM technology and it seems to be enough to allow humans to seem intelligent sometimes.
    2
  57. I first tried to learn Haskell circa 2002 during my CS studies in university. I decided to start learning to program with Haskell as a weekend project about a month ago. I was able to write a simple web server but failed to accept binary uploads because I was using string types that weren't binary safe. Some part of my program was silently dropping null bytes from the uploaded files! After finding out that Haskell has a lot of different binary string types and no automatic type coersion between string types I lost interest trying to debug my hobby project and moved forward because I was already able to figure out that the library functions I had to use were going to require use of different types for nearly every task. I still consider the effort/time equation of learning to use Haskell pretty bad. Rust seems a much better language to learn if you don't know either today. I think it's still good idea to learn some Haskell, similar to many other languages, because the more languages you know, the better programmer you'll be overall. And I still don't understand how people are supposed to figure out bugs in Haskell programs. You cannot even easily print to log messages or data from any random location in the code because writing to log would be a side-effect and changing every function signature to allow passing log related stuff just to debug the code seems like huge pain in the butt.
    2
  58.  @TurtleKwitty  I agree than when you can dump 'a everywhere and get the correct behavior, the compiler should be smart enough to do that automatically.
    2
  59.  @thekwoka4707  I was thinking more along the lines "declare that variable X can be shared between threads without arc mutex" which would automatically only lift the requirements for needing to use arc mutex but that requirement would be lifted everywhere, not in a single unsafe block.
    2
  60. Reducing microservice latencies by running the microservices on the same machine as the actual service that needs to access the microservice is a total no-go. The whole point of microservices was supposed to be scalability and if the only way to get the latency to acceptable level is to run everything on the same piece of hardware, you obviously cannot scale at all. All you got is extra overhead within the same hardware!
    2
  61. Great teacher monitors the learner performance and adjusts the teaching methods to match the needs of the learner. Bad teachers think that they are performing pre-scripted play and could be replaced with a YouTube video.
    2
  62. I think knowing a language vs being a master with it are two totally different things. If knowing a language were enough, anybody of us could write best selling books instead of writing software if we wanted.
    2
  63.  @adssib04  Which exact video do you mean? Internet of Bugs has multiple videos about Devin.
    2
  64. 4:30 I think the more interesting question would have been "for the projects that had clear requirements documented before the development started, how many actually matched the final end user needs?" – I would guess many waterfall projects did actually implement things as designed but I don't believe majority of those projects actually matched the user needs.
    2
  65. Microserves would be a great solution to many problems if communication wasn't limited by the speed of light and physical interconnects. When you physically separate all the computation, you are forcing processing to happen in serialized form and overall latency for a given request gets worse.
    2
  66. I mostly agree. Another option is to make every microservice to have hard deadline that results in good enough user experience. I would say that would be about 10 ms because you often need to combine multiple microservices for a single user visible response and the user experience starts to get worse when total response time goes above 100 ms. When you write a microservice with 10 ms deadline, you practically have to write it in systems programming language such as C, C++ or Rust. Do you have a team for it? Does that team agree that splitting everything into small microservices is the best way forward? If you use Java, Go or other managed language, every time the garbage collection runs stop the world step, all the requests for that microservice instantly fail their deadlines. So obviously you cannot use any of those languages without insane amount of hacks to avoid GC at all times.
    2
  67. I agree 100% that React is a framework. And you cannot sensibly run multiple frameworks at once.
    2
  68. You can also do general purpose deterministic fault checking with open source LFI toolkit but I'm pretty sure that way would be much slower to generate lots of test cases than running the code in simulator as explained in this talk. Another option is libfiu.
    2
  69. I've been writing software for living for 20+ years and I feel that hardest part is to get decision makers to clearly defined what's "good enough" for release. It seems to change randomly at least weekly.
    2
  70. Deterministic simulation with single random seed was pretty cool idea.
    2
  71.  @sophiophile  Btrfs has lots of great features but the runtime performance compared to ext4 and XFS has been too big a sacrifice to make it a bit hard choice. Yes, you cannot have all those features with zero overhead but the overhead has been too great historically.
    2
  72.  @RobBCactive  I've understood that Rust developers want known decisions when stuff changes. They are okay with interfaces changing but those changes must be intentional, not accidental. Currently the C developers seem to be thinking that they can avoid saying what the intent actually is and whatever is implemented is now spec instead. That is, any buggy behavior is part of the spec and if the buggy behavior is fixed, that's the new spec.
    2
  73. 31:00 As far as I know it, VS Code sends currently open files as context for the copilot. I consider it a nice way to guide Copilot because I can open related files and Copilot will only suggest related lines of code.
    2
  74. I can somehow understand that their regex test for the arguments failed to catch the failure but how on Earth their tests do not include "reboot the system after the update" considering their kernel driver is marked as critical for boot?? If they even an automated system that installs the update and reboots the system, the whole failure would have been caught before release. Clearly there was no real testing of any kind. And the scary thing is that they believe they are doing "multiple levels of testing".
    2
  75. Unpopular opinion: you don't need unit tests, you only need integration tests that cover the code so well that not even mutation testing can find any untested code. When you only test externally visible behavior, you can always rewrite the whole unit/library/module and when the new implementation passes those integration tests, it will be at least as good as the old implementation. Unit testing can pinpoint to the error in the implementation faster but unit testing bitrots faster.
    2
  76. 37:00 Handling network failures is really hard but it's not optional if you want any real world users. Especially mobile users trying to use your app in a moving vehicle are going to see all kinds of errors, disconnects and timeouts. Other platforms but iOS are less unstable but none can ever be perfect because TCP can only hide problems so much even if the OS were co-operating with your app. Some mobile networks might even change the client IP address every now and then!
    2
  77.  @duke54762  As I wrote, when requirements change after the fact, you always have to modify existing code one way or another. The astronaut architecture design means that you try to guess which extensions might be needed in the future and you try to design the printer interface generic enough to support HTML in the future even if it's not needed in current requirements. And it might be that the future requirement is not HTML but PDF which requires totally different API. My point was that you shoudn't try to guess about future requirements. Obviously, you should try to keep dependencies between all the modules as simple as possible but do not make the newly designed interface between the modules more complex than what you actually need right now. Otherwise you'll just end up with more complex API that will not match the unexpected future requirement change anyway.
    1
  78. If you had so many transactions that the single CPU thread on current database master machine cannot handle it, what then?
    1
  79. Even with current tech AI, increasing computational resources will always improve the AI network performance so claiming that AI has peaked is similar to claiming that oil has peaked and no further progress can be made. The big question is how close to peak of economically viable AI we are at the current state of art algorithms? If we used existing algorithms and just add enough memory and processing power, it's possible that the current algorithms could be good enough to result in AGI. However, I'm 100% sure that it wouldn't be economically viable with currently available hardware without improvements in the algorithms. We either need some new breakthrough similar to attention heads were for LLMs, or new hardware that can run modern networks with a LOT smaller resources.
    1
  80. I think that if you don't like reviewing code, you either (1) don't know the language well enough to understand what other people are writing, or (2) you don't care about the codebase you're maintaining. Code reviews are the only way to make sure your whole codebase doesn't end up being total crap with every part having different coding style (and I'm not talking about syntax here) and highly probably mistakes end up commited forever. Why don't we let commercial aircraft to fly with only one pilot because of risk of human mistakes, but at the same time we still think that it's okay to permanently commit into work of a single software developer without verification by another developer? And if somebody tells my that testing or QA will fix the issue, I'll just say "ha-ha".
    1
  81. TL;DR: ssh was supposed to use single-threaded but was executed as effectively multi-threaded thanks to SIGALARM being implemented incorrectly (single-threaded program should not cause any non-volatile changes to program state from SIGALARM handler). Had all of ssh been written as multi-threaded code the SIGALARM handler would have worked as expected because it would have had to use proper locking to access shared memory structures. Of course, that would have been true only if somebody had been able to write correct multi-threaded code in C – that is, without any security vulnerabilities. Even Linux kernel fails this every now and then. Human programmers are not careful enough to write security sensitive code in C except for random happy mistakes. Update: 41:05 Yes, in other words it's re-entrant bug. Shouldn't happen in single-threaded code in theory but incorrectly written signal handlers can break those assumptions.
    1
  82. I agree that if anything, DeepSeek R1 release will increase demand for GPUs. However, the release might increase demand for RAM even more.
    1
  83. Are there any post-quantum encryption methods that do not require really have handshake? Something like x25519 require transmitting 32 bytes but every post-quantum encryption I know about requires a lot of data which doesn't scale well for any TLS-like protocol.
    1
  84.  @Omnifarious0  I totally agree that handshake is required. The question is can to create a quantum safe protocol that can run on regular computers and require less than 1 KB for the handshake instead of multiple megabytes that quantum safe algorithms seem to typically have. The whole point of the handshake is to come up with a random 256 bit (32 byte) shared secret on both ends because AES-256 will be safe even with quantum computers.
    1
  85. 24:30 So their "content validator" didn't validate the content?? Even at so rudimentary level such as "the content is supposed to contain 21 items, check the length".
    1
  86.  @lupenn5914  How do you use syn cookie without already wasting the bandwidth for the incoming packet + sending the ACK? Syn cookie only reduces RAM usage of the server.
    1
  87.  @lupenn5914  Syn cookie can only reduce RAM usage of the server. DDoS will still eat all of your bandwidth in both directions and doesn't help with CPU usage at all.
    1
  88.  @Fs3i  The attacker can use a botnet but the defender must pay for 24/7 network connectivity. It's always unfrair game and you have to be Cloudflare, Google, Facebook or Amazon to be able to handle it without any issues.
    1
  89. The whole article seems to mistake retuning error values as "returning error as 8 bit int". If your only error value is a 8 bit int, sure, that's a pretty bad abstraction.
    1
  90. You test the tests with mutation testing. If mutation testing cannot make a logical change to the project source code without triggering at least one test failure, your tests are good because then all of the code is verified instead of every line executed at least once. Obviously, you cannot do any mutation testing before your tests have 100% code coverage which pretty rarely happens in any project not obsessed with automatic testing.
    1
  91. 22:22 This seems way too legit!
    1
  92. If you use CDN, you should be using Subresource Integrity (SRI). Read the MDN docs if you don't know how it works.
    1
  93. 12:50 I totally agree that we don't have good enough tests. Show me a project that has good enough tests that mutation testing cannot find problems in the tests. I'll be waiting for a long time. (Tests should be thought as a validation for the actual implementation and mutation testing should be thought as a validation for the tests. Every time a mutation testing can make a change a to the code without at least one test failing, those tests are not good enough! Are you going to be writing new features or new tests this year?)
    1
  94. I think the double quotes around the prompt text might have caused the quality to go down significantly.
    1
  95. 10:15 I think the highlighting without starting and ending on word boundaries is bad for viewers with OCD. If you start the highlight with a double click, your browser will automatically extend the selection boundaries to full words.
    1
  96. I agree that the article makes a major mistake of thinking that functional programming is the end goal. Functional programming has some pros and some cons. Good software engineering requires considering both pros and cons for every decision made for the project, especially when it comes to choosing the language to implement the project. For practical software engineering, I've yet to see highly successful functional programming projects. Do you think we have any highly successful operating systems, web browsers, office suites, web servers, NAS servers or AI systems written in any functional programming language? I think the most successful project is Emacs and I think that's pretty much simpler system than full operating systems or web browsers or GPU drivers. I'd love to be proven wrong, though.
    1
  97.  @cdoublejj  I started programming on Pentium CPUs and that was still slow enough to warrant learning Assembly.
    1
  98.  @artyshan5944  Do you actually think that 1 MB of extra dependencies is easier to understand fully? Or are you simply ignoring all the dependencies and simply hoping everything works in the end? I'm asking for real because I've yet to see a complex library without bugs.
    1
  99. I'm aware of Copilot pause, too. I'm trying to game myself the other way around: I try to write code fast enough to never see a Copilot suggestion but if I stall for long enough, let the Copilot suggest something to get out of the stall. My computer has wired FTTH internet connection so the pause needed isn't that long but I still try to write new code fast enough to never see Copilot suggestions.
    1
  100. 16:00 People often fail to understand how much faster computers are with sequential memory access and arrays win all kinds of data structures as long as the array fits in L1 cache and in many cases even if the array doesn't fit in L1. For details see great video titled "Bjarne Stroustrup: Why you should avoid Linked Lists" I wish the R in RAM actually meant performance.
    1
  101. 14:00 The thing he's describing seems like version visualization tools and totally agnostic to underlying version control system. Maybe he has some weird interpretation for the concept "version control system"?
    1
  102. 1:58 This has serious "mostly harmless" vibes to describe Earth in the HGTTG.
    1
  103. 0:15 If "returning errors as values" means "my function return value is int and it's zero if everything went okay and error code if something failed", sure, I like exceptions better. However, if the return value is something like Result in Rust, give me return values any day. And give me a nice shortcut to handle those like the "?" shorthand in Rust. The problem with exceptions (e.g. C++) is that when see code like void function foo() { bar(); zoo(); baz(); } Is this function correctly implemented? Can it throw? What if zoo() throws? You cannot know by reading the source code! And if you cannot know the behavior of a function even if you see its full implementation, you'll have problems in long run.
    1
  104. Another example of 80 % – 20 % rule!
    1
  105. From everything I've seen an read about safe C++ proposal, I cannot think it as anything else but Rust with weird syntax. And to convert any existing code from C++ to safe C++, you have to rewrite approximately 95% of all the code. However, if this basically gets full compatibility between C++ and safe C++ (read "Rust with C++ syntax"), I guess it still makes sense. The Rust interoperability is strictly C only.
    1
  106. 19:10 I totally agree that there's no causality between zero interest rate periods and current job market. I think the job market crashed because we're no longer in situation where any level of programming skill is enough and companies are firing extra people and try to cope with smaller amount of (still well paying) workers. New hires are going to see much worse offers compared to the situation a year or two ago.
    1
  107. 9:07 If you have non-shared in-memory state in stack only and follow RAII model, you can safely use exceptions. However, that's a HUGE if and rarely happens in reality if you look at the codebase accurately. And that assumption is never ever true for any old codebase and there's no sane way to start using exceptions after the fact when your codebase is already unsafe for exceptions.
    1
  108. 14:50 I think the biggest question will be if there are enough paying customers to make AI systems much smarter than GPT-4 et al, assuming that running smarter AI would be 10–100x more expensive because smarter AI needs so much computing power to run. If you had ChatGPT generate truly human-level responses but every response cost $1 or more, would you use it? If there are enough willing to pay for smarter AI, the progress will continue as fast as last couple of years. Right now it seems that computing costs raise exponentially compared to the intelligence that the system can show. It seems that there's no limit how smart AI system we could create even with the current design, but creating highly intelligent system would be insanely expensive.
    1
  109. So where's the ricing video?
    1
  110. All I want to know is that does this guy really want "world scale" version control where everybody creates new commits all the time in a single shared version history? If you think looking at history graph of a typical Git repo looks complex, imagine how it would look for "world scale" version control!
    1
  111. I was expecting to see Sora in this competition but maybe it would have crushed the competition too badly.
    1
  112. 25:40 The closest we have for "how has software programming changed in last 10 years" is the AI tools such as Copilot that we can currently use. Not yet groundbraking change but the signs are already visible that AI can really change things in near future (within 5 years).
    1
  113. 32:05 The Haskell line calculate :: Int -> Int -> Int is Haskell way of writing type definition for the function. In a mathematical sense it makes no difference if the function return type is considered to be {takes one argument and returns a function that takes one argument and returns an integer} or {a function that takes two integers and returns one} when both are called with two arguments. As a result, Haskell developers seem to believe that they want to define functions in mathematical sense. I can read that syntax but I most definitely don't like it. It appears that Haskell developers do anything they can do avoid using any parenthesis or commas. And as a result we have this Int -> Int -> Int stuff and dollar sign at the middle of the line.
    1
  114.  @cktken3336  Do you agree that "$" is just syntactic sugar and could be replaced everywhere with wrapping the rest of the line in parenthesis? Its sole purpose is to avoid writing parenthesis, nothing more. And JavaScript supports partial application, too. It just requires using bind() syntax to implement that. And with tracing JIT compilers in modern JavaScript engines you also get high performance with that.
    1
  115. Use Allman-8 style and you'll automatically avoid too much nesting from the start because the code starts to look really ugly really fast. I've been writing code professionally for 20+ years and I'm still thinking that if we typically use Allman style to teach programming, why ever change to anything less understandable even if it can compress more characters to smaller space?
    1
  116. 17:40 The time of day making a difference in LLM output from cloud services makes a lot of sense. Cloud LLMs are probably scaling their LLMs to less computationally heavy variants / config when traffic gets high and the answer quality goes down.
    1
  117.  @pureheroin9902  🤭My search history is actually pretty boring. Right now it looks like this: - phpunit assertequals github - css properties selectors sanitizer whitelist - sanitize css whitelist functions - phpunit assertequals clipped string - webp vs avif vs jpeg xl - what is intel ark - seagate exos helium - max fps cs - eu legislation consumer battery replacement - how Automatic Activation Device works - song of myself nightwish
    1
  118. 19:30 Have to love the comment putting both Haskell and Malbolge in the same class as esoteric languages!
    1
  119. Some JS developers seem to think that dependencies do not count at all and you have to minimize the number of lines you personally write. If having extra dependency actually had zero cost in real world, sure, that would make a lot of sense. When I add a dependency to any program I write (hobby or work), I do it with a plan about what's going to happen when (not if) the dependency is broken for any reason. In many cases the answer is "I'll be maintaining that dependency package from that on" and I cannot do that decision unless I look at the implementation and license of the dependency before deciding to use it. And writing a couple of lines of code myself is definitely much faster than reading the license and reviewing the code of the dependency. If you take extra dependencies with "I'm feeling lucky" attitude and do not check license nor implementation, then having an extra dependency may feel like a small thing and be faster than typing even two lines of code. However, if your coding style is "I'm feeling lucky", I'd hate to be your employer because I'm taking all the risk for your work.
    1
  120. 2:35 Trying to avoid using the terminal is not different from trying to avoid learning the language when you're in a foreign country. Sure, you can survive with pointing things and gesturing but that is far from the most effective communication method. Command line interface is harder to use than point-and-click interfaces but command line is much more efficient for most things when you know the language. And a developer writing programs in any software language has to be smart enough to be able to use command line, too, so it cannot be about lack of ability either. Don't be lazy.
    1
  121. I interpreted that as write as if you were doing TDD but skip the tests. However, the implementation should be written to be testable for all parts.
    1
  122. From the official Mojo manual: "Mojo uses a third approach called “ownership” that relies on a collection of rules that programmers must follow when passing values. The rules ensure there is only one “owner” for each chunk of memory at a time, and that the memory is deallocated accordingly. In this way, Mojo automatically allocates and deallocates heap memory for you, but it does so in a way that’s deterministic and safe from errors such as use-after-free, double-free and memory leaks. Plus, it does so with a very low performance overhead." So it's much closer to Rust than Java or J# or JS.
    1
  123. I have MSc and have been writing code professionally for a couple of decades and still I had to look up with sentential database is. From cursory look it seems to be generic form of relational database where the relations also include recursion and collation. Seems to be closer to pure mathematics than practical programming. However, if you can understand sentential database you're easily smart enough to figure out big-O notation.
    1
  124. I've figured out a pretty solid test to see if somebody knows Javascript: "What function hoisting and closure mean in JavaScript?" I've yet to find a good JavaScript developer that couldn't easily answer that. And I've found many JavaScript developers writing mediocre code and being unable to answer that. The just don't understand even the basic parts of the language correctly!
    1
  125.  @my_online_logs  How can the developer understand how the framework works if they don't understand the basics of the language they are supposed to use?
    1
  126.  @my_online_logs  If you try to actually ask these kind of questions from juniors, they cannot even tell you the things you explained. And yet they are writing code that tries to use the framework!
    1
  127. 25:09 I think this is just another example why early return is so good. It declares an edge case and clearly implements special handling for that.
    1
  128. The C/C++ short, int and long are always integers that have defined minimum size and the actual size is whatever the hardware can support with maximum performance. If some hardware can process 64 bit integers faster than 16 bit or 32 bit integers, short, int and long could all be 64 bit integers. That was the theory anyway. In practice, due historical reasons compilers must use different sizes as explained in the article. The reason we have so many function call conventions is also performance. For example, x64-64 sysv calling interface is different from x86-64 MSVC calling convention because Microsoft interface has a bit worse performance because it cannot pass equally much data in registers. And because we need to have backwards compatibility as an option, practically every compiler must support every calling convention ever made, no matter how stupid the convention was from technical viewpoint. It would be trivial to declare that you use only packed structures with little endian signed 64 bit numbers but that wouldn't result in highest possible performance. And C/C++ is always about highest possible performance. Always. That said, it seems obvious in hindsight that the only sensible way is to use types such as i32, i64, u128 and call it a day. Even if you have intmax_t or time_t somebody somewhere will depend it being 64 bit and you can never ever change the type to be something else but 64 bit. It makes much more sense to just define that the argument or return value is i64 and create another API if that ever turns out to be bad decision. The cases where you can randomly re-compile a big program in C/C++ and it just works even if short, int, long, time_t and intmax_t change sizes is so rare that it's not worth making everything a lot more complex. The gurus that were able to make it all work with objects that change sizes depending on underlying hardware will be able to make it work with a single type definition file that codes optimal size for every type they really want to use.
    1
  129. 22:15 I think the author is arguing here that when you change your program to introduce new error case (throw from a function that didn't use to throw) it's a nice thing(?) to not change the signature. Isn't that argument basically saying that I don't care if anybody is able to anything sensible with my newly introduced error case? How is that supposed to result in improved stability or higher software quality? I much prefer the Rust way where change in interface (hey, this thing can now throw errors instead of being successful every time) requires the calling code to actually handle that error.
    1
  130. I consider Atom as VS Code version 0.1. It basically had the same pros and cons.
    1
  131. 24:02 I still cannot understand how you are able to say things like this with a straight face!
    1
  132.  @guillaumebrunerie  Same happens with npm way too often. The code you get from npm doesn't match the code published in GitHub for many projects!
    1
  133. 13:40 If you really create yet another class to print an invoice, and then yet an another class to print book details etc etc you end up with totally insane amount of classes. Sure, you only need to modify one class at a time but having insane amount of concepts (classes in OOP) is not free either.
    1
  134.  @duke54762  My point was that if you're printing a simple text output, you only need to include actual text data into the stream. When requirements change and you now want to emit extra information such as images of the products, use custom fonts, use department letterhead and change the output from HTML to PDF, the API will look a lot different because the existing data is not enough. You could try to foresee this requirement from the start and add extra objects to the API that allow defining style and object photos and whatnot and you'd end up guessing wrong.
    1
  135. I think I have at least some "fear of failure" but that's for having a bug that corrupts end user data in some yet-unknown way so I cannot even test for it. Preserving existing data is the most important task in my opinion, especially if the data was manually created by the end user. And I'm not afraid of losing data because I have backups. I'm afraid of the new feature that the end user uses modifying the existing data as a side-effect when user intentionally makes some related change to data. For example, if you have rich text data and you want to add a new feature to the rich text editor, how can you be sure that the new feature doesn't cause problems with existing content? If the end user modifies the content with your new & buggy editor, there may be no way to fix the result without either losing the intended change (that is, revert to last known good version) or having corrupt state (that is, you want to keep the intended change but part of the historical content is now corrupted and the end user must manually fix it). I guess I'm afraid of wasting end user time because of a mistake I make (which doesn't get caught in testing or QA).
    1
  136.  @lost4468yt  I totally agree. Most software developers I know are not exactly stellar in communicating with normal people. As a result, AI will take over programming jobs once the AI is intelligent enough and cheap enough to run. If I understood correctly, Devin already costs hundreds of dollars to use for even simple tasks. That's not a threat to human programmers at that cost level, especially when Devin is not yet at even jurior developer level. However, give it a couple of years and it's at junior developer level and costs $0.10/h to run and trying to get any new human developers to senior level is going to be really really hard because all junior positions will be taken by AI.
    1
  137.  @Leonhart_93  That's true and with Rust, you can pretend that most of the memory is automatically garbage collected because it's internally either ref-counted or lifetime is decided during compile time. However, such solutions cannot handle with data structures that use reference loops. For those, you need to use some kind of manual book keeping such as weak pointers or manually breaking the loops.
    1
  138. 13:10 I think an awesome engineer must have great communication skills but it has nothing to do with public communication. I do believe that you have to write a lot to become good at communicating in written form and writing human readable source code is definitely a form of communication. However, being able to communicate fluently in English doesn't mean you're fluent in Chinese, JavaScript or Finnish. I do agree that being able to express complex thoughts in understandable way in any language demonstrates ability to think which is obviously important to be the "best programmer".
    1
  139. 19:19 Am I the only one that read "ffmpeg out to ship with Windows" with a reaction that "Do you really think that ffmpeg should include all of Windows in the monolith, too?"
    1
  140.  @christopheroliver148  I think preemptive threading is just a small subclass of parallel execution. I would argue that parallel execution even includes stuff like Spectre and Meltdown vulnerabilities.
    1
  141.  @christopheroliver148  I took "cache invalidation" and "naming things" to be pretty generic, too. Preemptive multithreading is just the part that most programmers have to consider because that's the minimum bar to do any kind of parallel processing that improves performance. I feel preemptive multithreading is the easy part compared to more complex stuff. Especially with x86-64 platform where the architecture has easy-to-use guarantees for memory syncronization. On ARM you have to always execute extra instructions to syncronize even RAM contents between cores because CPU caches are not guaranteed to be synchronous.
    1
  142.  @gruntaxeman3740  Yes, and you can run different processes on different pieces of hardware. In fact, you may want to do this for redundancy even if you don't need to do it for extra performance. And avoiding races and split heads is really hard when when you want to handle the case where a single computer or network port or a switch suddenly fails or hangs.
    1
  143.  @gruntaxeman3740  There are multiple solutions to handle multiple threads. You can avoid state machine with locking as long as you always acquire locks in the same order. If you try to use locks and acquire locks in somewhat random order, you''ll end up with a deadlock sooner or later. However, the best implementation depends on the actual algorithm and hardware you're using because performance optimized code always depends on CPU cache implementation these days. And since the cache implementation is not documented, you can only write some code and test it to see how it performs.
    1
  144.  @mayaens  Yes, I meant &mut X but was too sloppy in communication. Thanks for pointing it out.
    1
  145. "With C the most complex data structure is linked list" – all I hear is "skill issue". "You often need garbage collection" – another skill issue.
    1
  146. I still think that everybody with CS degree should have learned Assembly as mandatory part of their education. You're not expected to use it on daily basis but you should definitely understand how some simple C code is related to Assembly. Without that level of understanding, you cannot write high performance code except by accident because you don't understand how the system works.
    1
  147. 36:30 More instructions == slower is not always correct. It really depends on instructions and how those will be decoded to micro-ops and how those get executed in the CPU. I wouldn't even bother looking at the amount of instructions, just profile it. And if you're actually interested in instruction count for some reason, compile with with -Os which asks for smaller instruction count.
    1
  148. 22:00 I think "e" is for integer (when you consider how the "i" in integer is pronounced). I'd definitely use i, n or k for this kind of context.
    1
  149. 5:00 100% agreed!
    1
  150. Coding is already ultimately just prompt engineering. The current "AI" system we have to actually create the software are typically called compilers and the prompt is called source code. And because existing systems are so primitive, prompting those to output an usable software is really hard, hence the need for pro software developers. Future AI-based compilers may be able to understand instructions that are at or near the level of average human communication. And if such future AI can generate the resulting software rapidly and for cheap, it doesn't even matter if normal people fail to communicate their needs at first because rewriting pieces of software will be so cheap that it doesn't matter if there are misunderstandings and creating software that will be thrown away immediately when it has been made. The reason great human software developers work so hard to truly understand the needs of the end user before writing the code is because they want to avoid wasting work. If work is next to free, normal people can just iterate the full software and generate the spec by telling AI to replace the incorrectly guessed parts until the resulting software is deemed good enough for them. It all boils down to communication. The party with money is trying to communicate what they want and the current way to creating software is definitely a compromise because software development is so expensive right now. And most software ever done is broken in every imaginable way and just barely works well enough to be usable. Before AI, I was thinking that there will be always programming work available because we cannot ever fix even all the existing software for real.
    1
  151. 6:19 I disagree here. Unless the error message comes from the software you maintain and you write good error messages that actually match the error case described by the message, you cannot trust that the root cause actually matches the error message. Especially if the code uses exception handling of any kind. More often than not the catch clause is too generic and then blame the only issue that the original author of the code was thinking and any other reason for the same exception will also trigger the very same error message. Typical example would be catching an IO error and reporting "file not found" when the true cause was access denied for one of the path segments.
    1
  152. I agree that the problem was that the benchmark was "running concurrently" when every "thread" was sleeping. If every thread had acquired accurate timestamp from the OS, formatted it into a string and appended it into a file as a single line and repeated that 100x before exiting, we would have seen at least some real processing and you could check the timestamps to see how concurrently things were happening. With a "task" that sleeps and exists you basically have a queue of tasks than can be processed one after another. Zero parallelism.
    1
  153. 7:56 I think you missed opportunity to call this "Microsoft Hello". Always go for a real product name if one exist :D
    1
  154. Real programmers use butterflies. See XKCD 378 for details.
    1
  155.  @JohnDoe-ln8jp  The only problem with MindVM is that you cannot get any hardware upgrades for it. If the problem is more complex than can fit in RAM, it cannot be used.
    1
  156. Stackoverflow does have members that wanted to be local Sheriff as a child and now they are expressing themselves by going through all new questions and playing "you didn't follow the law" game. RTFM the documentation given to new users would help but I don't agree with following rules to letter if the question itself is sensible.
    1
  157. Why bother poorly authored "language benchmark" when project called The Computer Language Benchmarks Game is already available and has about decades to improvements to implementation of each variant of the program. If somebody can figure out how to make language X faster for the task in benchmark, that version will replace the old benchmark version.
    1
  158. 17:00 Pep talk of the year!
    1
  159. Interesting architecture. I would have guessed that having constant wallclock timing for "airplanes" would have been even better than having a constant limit of "passangers" per plane. For example, send new airplane every 10 ms and you'll get 10 ms latency for any given transaction as long as you can handle any plane in 10 ms.
    1
  160. 48:07 "I like how they use word 'easily'" – I agree. It would be interesting to hear what kind of task the authors would call "barely controllable" or "nearly impossible to control".
    1
  161. I would define functional programming by saying that it's any language that has functions as first class objects and no mutatable state on variables. As for OOP, I would consider any language OO that has the built-in syntax for function call indirection via object instances in addition to ability to capsulate object related data inside the object (logically or physically). To be worth using, it should allow delegating the implementation to another code; possible solutions include prototype inheritance, class inheritance or maybe even traits nesting only (e.g. PHP Traits). For example, if you write JS code without ever creating any variables (that is, strict mode and only ever use const) your programming style is definitely functional. However, the usual way to use JS is definitely OO procedural.
    1
  162. I do write answers to Stackoverflow and I expect the new users to RTFM. However, I rarely downvote bad questions unless it's spam or something else obviously malicious, I simply ignore them. If I downvote a question, I always write situation specific explanation for it to help the human being asking a bad question to understand the problem. Linking to generic "wrong type of question" page is just bad in my books unless the content is obviously malicious. And even in that case, the correct action is to flag the question for admins, not to downvote it. That said, if you cannot bother to read the documentation provided to you before you ask the first question, do not expect other people to bother to interact with you either. The instructions clearly explain that you should tell what you've already done and how it has failed. The intent of the site is not to do stuff for you – you have to demonstrate your work first and then ask other to help with the mistake you fail to see. If you don't want to bother to read or work, do not expect free support. I participate to StackOverflow because I believe in teaching things to other people and it makes me better communicator in general. I feel that I can explain things better to my collegues once I have learned to teach other people on StackOverflow. My reputation is around 15k which should give some idea how much I've used it. And I think StackOverflow does have too strict rules about what kind of questions are acceptable. I've been downvoted for real questions as being too opinion based. Most programming tasks are some kind of compromise and it would be valueable to explain what each developer would choose and why. Even if the why is opinion, not a perfect statistical fact.
    1
  163. 3:20 A regex engine running inside critical kernel driver – what could go wrong?
    1
  164. I think people should just stop speaking about "indexing" but talking about "offset" instead. Then it would be much easier to wrap your mind around the concept correctly. It's obvious that offset from the start for the first item is zero. You can dedicate the word "indexing" for pre-computing search data. As in search indexing. Languages other than C use offsets, too, because the offset counts elements, not memory addresses. And one could argue that C counts elements, too, not memory addresses because s = s + 1 goes N bytes forward when s points to type longer than 1 byte. And you'll always have off-by-1 errors regardless if you call your things "index" or "offset". The best thing you can make is to avoid using words that have mixed historical meaning, for example "index". There's no similar mixed usage for word "offset".
    1
  165. Automatically deleted test data MUST be configured to not be accessible by actual customers.
    1
  166. I don't believe it's possible to make great contributions without also being user of the software you want to contribute to. If somebody wants to create open source contributions for their CV, they should start by daily driving open source and then fix issues they hit. For example, if you don't like how your window manager positions newly created windows, write a patch for new behavior and implement UI to make the change optional. Then you can offer that feature to the original project. And the project may accept your contribution if the idea is good enough and implementation is good enough, too. And the feature and UI you create will be good because you made those changes as an improvement to user need (that's your own needs). However, this need should be about real need, not something you picked up from thin air to pretend it's an issue just so that you can create a patch for the project. If you don't use open source software, you cannot make credible contributions to open source projects.
    1
  167. I was disappointed that this video didn't have any examples of non-euclidean Portal 2 community maps. For example: https://youtu.be/FuEuqX3XDhM?si=Rwr_hIPN_My9GFXC&t=147
    1
  168. 24:40 Just wait a couple of year when people mostly speak to AI where it's okay to interrupt the other party at will. Can you see any potential problems with human to human interaction when that's the rare case when you should behave?
    1
  169. 2:30 Newflash: major changes cause conflicts! Another newsflash: if you cannot make it work with opt-in style, forcing it by mandating it will cause more conflicts.
    1
  170. I have written code in both office and remotely from home and I can do either way. However, I'll ask for higher pay for the same work if I have to commute to office and back.
    1
  171. 14:00 My point about technical debt is that I should be able to reduce technical debt in long run, not increase it. Sadly, many companies do not even try to achieve this.
    1
  172. I'd argue that Rust is the only language you should use for multithreaded code because creating an accidental data race in any other multithreaded language is way too easy. Even with Java, you have to manually mark methods as synchronized or never use any shared memory structures and lose most of the performance win you could have with multithreaded code. With Rust, creating a data race is really hard unless you use unsafe blocks.
    1
  173. "Always better than SAML". --- 100% agreed! SAML is about "we want to create auth system but we don't believe TLS works for encryption so we roll up our own" combined with "we don't believe transmitting data between servers so we use browser redirects to transmit packages between servers". Of course, SAML requires secure "metadata updates" which are transmitted over TLS so the security still depends on TLS! The bad part is that it's possible to build a working system on SAML and that's why it has never been totally killed of even today. OpenID Connect wins SAML in every possible way and is really easy to implement. And even OpenID Connect has extra crap like encoding data in base64 encoded JWT packages instead of simply using JSON to transmit data.
    1
  174. 26:55 It's not possible to handle OOM Killer from regular program. Once kernel OOM Killer chooses your process, you get zero additional CPU instructions before the process is killed. Try handling that! The best you can do is to put critical processes in cgroup and add a custom OOM handler for that group. However, if your process is critical realtime process, that's not a real option for you.
    1
  175. The negative prompt is the things you don't want to see in the generated output. Most AI generators give you better results if you use negative prompts such as "malformed, blurry, messy, pixelated, bad physics, inaccurate". One would expect the system prompt to include such negative prompt automatically but nope.
    1
  176. 16:35 When you've been waiting for 3 days, now you have surely read the documentation you were provided in the first place, right? Right?
    1
  177. Is somebody still using some diff tools that do not support "ignore white space change"? Even gitk has an UI toggle for that and on command line GNU diff supports -Z, -b, -W, -B, -I to support different kinds of whitespace ignore that you might want to have.
    1
  178. Starting with P100 latency when you start improving the performance of the whole system is a great starting point of any system. It's still surprising that Zig was selected over Rust. I understand that Zig implementation was probably easier to implement but Rust implementation would have provided more safety against implementation errors which I would have considered critical for financial database. If your runtime safety depends on additional runtime sanity checks, are you really faster than Rust implementation that can guarantee the same safety with compile time checks? Of course, if you want to catch CPU errors, too, you obviously need also runtime checks. I think financial database should have all logic checked at compile time and also have runtime checks to verify the hardware.
    1
  179.  @drofdissonance  Full control over allocated memory could definitely be one valid reason. That was the main pain point of Rust that had to be fixed before Rust was allowed in Linux kernel, too.
    1
  180. If you already know what Git is, the only thing you need to know that Mercurial has multiple things that Git users see as branches. 1. Mercurial has unnamed heads which seem quite like branches to Git users. When you create a commit in unnamed head, the commit doesn't save any branch name in the DAG. 2. Mercurial has named heads which still seem quite like branches to Git users but when you create a commit in named head, the commit metadata will store that branch name forever. This requires giving more thought to the branch names because those will be stored forever in DAG. 3. Mercurial also has feature called bookmarks which is closest to Git branch: you get a real name for a branch but it doesn't get stored in the version history as metadata. And if you use some git-hg bridge (similar to git-svn), be sure to figure out how it is going to handle above branch-like things from Mercurial to Git and vice versa.
    1
  181. 32:10 OpenAI could just take 1o output and throw it to GPT-4o with a prompt "Please make the following text more fluent without changing the meaning of the text" and have an ultimate model that makes people at least as happy as GPT-4o for all tasks.
    1
  182. 26:00 I have to agree that the suggested metric doesn't make sense. Basic diff has just two operators: remove line or add a line. When you read diff, red lines have been removed, green lines have been added. Really simple. This new improved format may reduce number of lines slightly but in return you get a LOT more complex operators. Instead of thinking "is this line red or green?" I have to think "is this line deleted, added, moved, copied or just white-space adjusted?" – for every single line of code repeatedly. I think having a normal diff reader that supports "Identical segments with more than 5 lines are collapsed by default and rendered with summary "Moved function XYZ". That is, an improved tool for reading the existing diffs would be much superior method. I think the whole stuff was designed by a non-programmer who totally failed to understand what actually matters. If I were interested in lines of text, I wouldn't use 15 line context for my diffs.
    1
  183. I think for some reason he thought that opposing sides should add to 6.
    1
  184. 15:20 It's already absolutely clear that Winamp developers never RTFM for Git. And they probably don't fully grok Windows either keeping those .exe files in random locations.
    1
  185. 13:00 Most of the time, the problem is interviewer skills. Creating a plan for an interview to meaningfully differentiate bad developers from good developers is really hard. Leave that to HR department and you'll see failure with ~100% probability. The hardest task I can imagine in an interview is a task where you're given some code (say 50–100 lines) without type definitions and ask the interviewee to explain the data structures used and to tell if the existing code uses problematic algoritms (e.g. poor cache locality, high memory usage or high CPU usage if data structures grow bigger) or contains security vulnerabilities. If somebody is able to read code written by other people and understand it deeper than the surface, they must be a good developer already. No need to write any short fragments of code because for real work they could use Copilot to get baseline code that they can then fix.
    1
  186. X is faster than C assumes that you're discussing about {time to write the code + run the code} instead of {run the code}. Often writing something in C requires more time than equivalent code in some higher level language. However, for me writing Haskell is so slow that I'm more productive with C. On the other hand, I can be more productive with Rust than C.
    1
  187. Even if Devin could do nothing else but read the documentation, read the code and submit pull requests for fixes to documentation, it would be great. Assuming it's cheap enough to use. The demo to read a blog post and repeat the same thing with ControlNet for about $750 is not a threat to any human developer.
    1
  188. I think modern LLMs could learn from AI generated content, including content emitted from the LLM itself. However, the data would need to be first checked before used for training new data. I think GPT-4o and GPT-4 could make pretty good work in checking the potential new data with good enough prompting. Something along the lines "Does the following explanation/idea/research seem sensible compared to existing scientific knowledge? Provide chain of thought." followed by the LLM generated answer / LLM generated idea / LLM generated research paper. And maybe check the provided chain of thought with yet another LLM to check if it hallucinated. Humans do not need to read all research papers ever published to generate sensible output. Successful humans do have a concept of input filtering: when you read any new piece of data, you automatically evaluate the quality of the content given your existing understanding of the world. The better understanding of existing research you have, the better you can evaluate the next incoming data. And always ask for chain of thought because LLMs are too happy to hallucinate simple yes or no answers.
    1
  189. Using C and errno as an explanation why ALL returned error values are bad is a strawman if there ever was one. C and errno was probably high tech in 1975 but we have already understood that it wasn't the best interface you can create.
    1
  190. 0:53 After a quarter century of programming, I usually literally go for the source – that is, read the actual source code of the library you're going to use because even the official documentation always lies. You can use the documentation as introduction to code. This is also the reason I only use open source libraries. If I cannot see the source, I don't know how the implementation is going to work because the documentation always lies. Not intentionally most of the time but unless the documentation is automatically generated from the actual source code, it will always fail to describe the actual implementation more or less.
    1
  191. 21:45 Code coverage (with automated tests) is better than nothing but the real automated testing starts at 100% code coverage because that allows you to start using mutation testing. The whole point of mutation testing is that's the only way to validate your test suite. I can promise you once you hit 100% code coverage first time, mutation testing will find a lot of missing tests immediately. I would claim that you can be pretty sure about your code quality once you have automated tests where mutation testing cannot find possible changes anymore. At that point your code is really stable but it's still impossible to say if it actually matches the user requirements for the whole project!
    1
  192. 6:50 I think this is just modern version of Netscape "let's rewrite everything because we're going to make it much simpler this time" – the end result is always, nope, the complexity is actually real and you cannot make it simpler without dropping features. The best you can do is try to improve existing implementation if you're not willing to lose features. This is because the only accurate enough specification for the existing behavior is the existing code. All the other requirement lists and specifications always lie.
    1
  193. 9:00 Repeat after me: only defaults matter If an argument is critical, make it mandatory and explicit instead of using a default value.
    1
  194. One could also explain N64 as having no RAM at all but being able to run CPU instructions from VRAM if GPU is stopped while that's happening. And there's 16 kB cache in the CPU itself so as long as you can keep everything in that space, the GPU doesn't need to be stopped.
    1
  195. If you literally have 100k repos in a company, you're doing something seriously wrong. Unless you're counting the clones, too, meaning that a engineer working in 5 projects will increase the counter by 5 at minimum and much more if they have multiple working directories and/or submodules. And with distributed version control, you do want lots of clones and if you think that's a problem, you just have minor brain damage caused by CVS and SVN. I would have wanted to see them ask what kind of features this interviewee was looking for. From everything I read between the lines, it seems to me that this developer just really likes more centralized version control and Git clashes quite badly with that. And Google internal systems probably have good enough networking so they can actually make centralized version control to work well.
    1
  196. I'm actually surprised that @ThePrimeTime didn't already know all the stuff discussed in this video. I was expecting that every good developer already understood CPUs at this level. I think x86 and x86-64 assembly should be considered as command protocol and the actual hardware runs micro-ops instead. And yes, there's also hardware to convert this command protocol to micro-ops format. This conversion can be improved and next gen CPUs have better and better converters built in hardware. I guess in long run we might even have hardware tracing JIT compiler for this conversion! If you hardcoded the micro-ops in the binary assembly, then the manufacturers couldn't improve this part and you'd be always limited by micro-ops execution bandwidth. The 64-bit Intel Itanium basically tried to go this path and it seriously failed. And the complexity of this part is not that important because modern process technology can put about 100 million transistors on a single square millimeter.
    1
  197. 6:49 The most important point of this video: if you only look at total sales and ignore how those sales happen, unethical things will happen for sure.
    1
  198. Copilot Business costs $19 per month instead of $10 per month if you're concerned about your code being used to train the system. Copilot Business doesn't leak data (assuming you can trust Microsoft in general to keep their promises) but it cannot learn from your use either.
    1
  199.  @sophiophile  Good points! I typically consider filesystem performance assuming cold cache because that's the situation where you get the worst latency and the filesystem architecture matters the most. If you have small enough amount of data that it can fit in caches, Btrfs is definitely a good option. Btrfs can also handle RAID1 setups with mixed sized devices even better than mdadm or ZFS, especially when you're extending existing array with new devices.
    1
  200.  @RobBCactive  Sure, the only way in long run is to have accurate API definition in machine readable form. Currently if you use the C API, you "just have to know" that it's your responsibility to do X and Y if you ever call function Z. Unless we have machine readable definition (be it in Rust or any other markup) there's no way to automate the verification that the code is written correctly. It seems pretty clear that many kernel developers have taken the stance that they will not accept machine readable definitions in Rust syntax. If so, they need to be willing to have the required definitions with at least some syntax. As things currently stand, there are no definitions for lots of stuff and other developers are left guessing if a given part of the existing implementation is "the specification" or just a bug. If C developers actually want that the C implementation is literally the specification, that is, the bugs are part of the current specification, too, they just need to say that aloud. Then we can discuss if that idea is worth keeping in long run. Note that if we had machine readable specification in whatever syntax, the C API and Rust API could be automatically generated from that specification. If that couldn't be done then that specification is not accurate enough. (And note that such specification would only define the API, not the implementation. But such API definition would need to define responsibilities about doing X or Y after calling Z which C syntax cannot do.)
    1
  201.  @RobBCactive  Do you agree that if we have a function like iget_locked() and after calling that function you MUST do something with the data or the kernel will enter in corrupted state, this behavior is part of the kernel API? Now, do you agree that C cannot represent this requirement? If you agree both previous points, then you must also agree that there cannot be even in theory a compiler that can catch a programming error where the programmers fails to follow this API (assuming we only have C code as machine readable input data). Rust people are trying to say that quality of the kernel would improve if we had a compiler that can catch errors of this kind. And Rust compiler can already do this if you encode the API information in Rust syntax using types to represent the API behavior. And it seems that Linus agrees and that's why Rust was accepted into kernel despite the fact that the Rust syntax has much higher learning curve than C. The C developers that want to downplay Rust are basically arguing that either (1) there's no need to catch programming errors automatically, or (2) having to write the exact requirements would be too expensive so it's not worth the effort. Which camp do you belong to? I'm personally definitely against (1) because I see kernel level security vulnerabilities and driver crashes way too often. And about (2) I'm not that sure. I think it's worth the effort to try it to improve the quality of the kernel. And the reason to try to use it for filesystem interfaces is because the filesystems are so critical for data safety. If your GPU crashes every now and then, that's non-optimal. If your filesystem randomly corrupts data when threads access the shared data incorrectly or some piece of code does double free, that's a really bad day and hopefully you had backups.
    1
  202. 20:05 Considering that the only reason Firefox went with Mercurial over Git originally was because Mercurial had better Windows support and many enough Firefox developers worked on Windows machines. When Git was nice enough to use on Windows, there was zero reason to keep using Mercurial for Firefox.
    1
  203. 16:45 I think he was talking about Python 2 where print is not a function so there are various limitation where you can write it. The problem was that bad that Python developers decided to make Python 3 a not-backwards compatible language (read: a different language) just because they hated the old "print" that they had created previously.
    1
  204. Modern programs use lots of RAM and CPU because most programmers skip any kind of optimization nowadays. As long as the customer is happy to pay for more hardware, it doesn't make sense for the software vendor to use more hours to optimize RAM or CPU usage. I'm not happy with that tradeoff but I fully understand where it came from.
    1
  205. I've been writing software professionally for 20+ years and all I can say is that there are no silver bullets. You can write great code and crappy code with any turing complete programming language. I've yet to see any examples where FP or OOP is obviously better. If you truly don't want to use any libraries and want to write everything from scratch, Haskell style FP may be easier for writing parsers.
    1
  206. 16:00 Most decision makers will understand that having yet another meeting doesn't make sense when you explain how many dollars are wasted during that meeting when people are not doing productive work. (Simply multiply the salary of every meeting attender with the length of the meeting + some extra because attending the meeting will destroy your flow every time.) If the meeting cannot provide at least that much extra value, do not have the meeting at all.
    1
  207. 1:00:10 The most important reason this is the correct way to handle your own branch is because you get to resolve conflicts one patch at a time. And since those patches were created by you, it's typically super simple to resolve small conflicts. If you try to merge big feature branches, you get to solve all the conflicts at one go instead of by patch.
    1
  208. In my experience CoPilot is about the same level as 1st year student in random university for CS Major. The skills are really lacking but still above layman. I don't feel that CoPilot can do a lot of usable work but it can do some. My thinking is that CoPilot business account costs about 20 EUR per month and it can probably save that amount of work so using it is free. Definitely not 10x or even 1.5x overall productivity. Maybe more like 1.01x in a good day.
    1
  209.  @harimohan2840  I would say MIT because Apache 2.0 license has the requirement that you have to declare the modifications you have done to the original code if you fork the project.
    1
  210. @ThePrimeTime the description is still missing the link to computer enchance.
    1
  211. The second column is logically "how many idle cycles we cause for the GPU to wait if we run these instructions on CPU (as a result of using shared memory bus)". But you can allow the GPU to keep running if your code only uses CPU cache instead of RAM.
    1
  212. This all sounds like they had code reviews for their scripting engine but no reviews of any kind of the actual data updates. All the stuff about mock data suggests that those tests were only about the scripting engine. And the "content validator" not bothering to even check the length of the data points to major skill issues. It would be interesting to know what kind of stuff they were trying to validate?
    1
  213. I'm afraid that somebody considering software developer as a career would consider this a real video.
    1
  214. 15:20 If you want organic collaboration between these parts...
    1
  215. 15:00 I'm a Linux user using VS Code and GitHub. Those are totally acceptable for me because I have a clear path forward in case MS ever changes their behavior to be too bad for me. VS Code is open source so I can simply fork the last sane version and Git works just fine without GitHub, too, so I will not lose any history or have to change my personal workflow except for the GitHub user interface. GitHub is not centralized source control, it's just a commonly used place to keep a copy of your repository online.
    1
  216. After writing code for a couple of decades for living, I totally agree that DRY is about a compromise. I've come to conclusion that the rule should be "if you copy the same code to 3 different locations, you should fix the code". In addition, typically the best code can be created by first copy-pasting code, then writing the optimal solution for the task at hand using the copied code and then merging the copy-pasted code and the original code if that makes sense for long term maintanability. The only things that are important in long run are readability and maintainability. Changing the actual algorithm to more performant version is okay but micro-optimizations that make the code less readable are nearly never worth it. If you truly need to micro-optimize some inner loop, the code should come with a big f*cking comment block explaining why it's needed.
    1
  217. I've been writing software for living for a couple of decades now and I do use copilot. The way I see it, it helps with some minor stuff and as long as it saves enough work per month to pay for itself, it makes sense to use it. Copilot is definitely 50% or 250% boost like some people seem to believe but it may be 15–60 minute worth simple stuff done automatically per month and then it makes sense to use it. I'm still not sure if having it on by default (rendering suggested text in grey) is good or not. I sometimes feel that it would be better to only have a suggestion with a special key combination only so I don't need to waste brainpower to check the suggestion when I'm willing to write the part myself. And using Copilot does feel like prompt engineering with hacks such as keeping suitable files open in my editor (I'm using Copilot with VS Code) because Copilot uses the contents of currently open files as context for its suggestions. And I'm aware of Copilot pause, too. I'm trying to game myself the other way around: try to write code fast enough to never see a Copilot suggestion but if I stall for long enough, let the Copilot suggest something. My computer has wired FTTH internet connection so the pause needed isn't that long but I still try to write new code fast enough to never see Copilot suggestions.
    1
  218. 20:30 I see this as argument that is logically "I don't like the syntax of Rust" and the implicit case (without "&" or "owned" or "^") should be different than it's for Rust. That is, skill issue. That said, Mojo seems to have lots of good ideas so it's definitely yet another language worth learning.
    1
  219. 10:20 I think this viewpoint is simply false. Since good IDEs can show last commit that modified each line, you can nowadays have line accurate description of why each line exists in the source code without having human written comments in the source code! However, if you fail to write proper commit messages (documenting why the code is needed), you can never achieve this level. And if you write proper atomic commits with proper commit messages, you always rebase and never merge your own code and everything will be fine. And if you're pulling remote branch and it can be merged conflict free you can do real merge if you really want. If there's a conflict, do not even try to make a merge but tell the submitter to rebase, test again and send another pull request. The single biggest issue remaining after Git is handling huge binary blobs. If you want to have all the offline capabilities that Git has, you cannot do anything better but just copy all the binary blobs to every repository and if you have lots of binary blobs, you'll soon run out of storage. If you opt to having binary blobs on server only, you cannot access those in offline situations or when the network is too slow to be practical for given binary blob. 12:20 This wouldn't be a source control system, it's just a fancy backup system. The problem discussed here is total skill issue only. I personally use Git with feature branches for even single developer hobby projects and I spend maybe 10–20 seconds extra per branch total.
    1
  220. 4:00 There's a way to write accurate description of what you want the computer to do. That thing is called "source code". If you cannot write accurate description, then you need some kind of interpreter that can take your flakey description and ask smart questions about your needs to understand your needs correctly. And then generate the required source code. Right now, this kind of interpreter is called "programmer" or "developer". Devin promises to be replacement for this and it might work if it's a true AGI system. I'm not holding my breath.
    1
  221.  @n00blamer  Typically XOR would use syntax a^=b because usually % means remainder for a division.
    1
  222. 14:15 I think the most important thing to understand that every team must invent their own methodology if they want to be effective. You cannot just copy some magical "one-size-fits-all" method that would actually work for real. Some say that developers are like werewolves: always afraid of magic bullets.
    1
  223. The section 7 seems to be going pretty heavily into "can we trade higher latency for more throughput?" I would assume that when somebody uses binary search, they would prefer to have low and predictable latency for any given single query.
    1
  224. I mostly agree but if you make everything super slow then your code ends up really bad until one single part overwhelms all the rest. I think it's better to decide the required latency at the start and then do whatever it takes to keep the final performance at least as good as your decided latency. For a game, the decided latency could be 1/30 or 1/60 seconds to match typical displays. For a web service, the target latency could be 50 or 100 ms. Then you know when you have to start optimizing: whenever your existing code cannot meet the latency requirement. What to optimize? The part that overwhelms everything else at that time.
    1
  225. We have a rule for our team that you have to document all public methods for a class. You don't need to write title line if the function name is descriptive enough but you have to document non-trivial arguments and you have to define the return value accurately. If you don't like writing documentation, try to mark methods as private as much as possible. The idea of documenting the public interface is similar to design-by-contract in Eiffel language. Without documenting the expected behavior in human readable form, you cannot know how the method should be fixed in the future when you hit some case it cannot handle correctly. Nobody expects you to comment individual lines unless those are a workaround for some external component. In that case, you should document why the workaround exists and why it works because that behavior depends on external component and if the external component ever changes, you need those comments to understand the change in behavior. And if you write any kind of workarounds, try to do feature detection instead of checking for version numbers to decide if the workaround should be applied or not.
    1
  226. "When it's done right" is just another variant of "No true Scotman".
    1
  227. I would argue Haskell is much much harder language to master than C, C++ or Rust.
    1
  228. 15:33 Some developers have weird allergy against doing multiple return statements and they end up with crap like stuffing a lot of code in one ternary statement and pretend that the code looks nice. Always do early return if possible and avoid all the nesting and complex multi-line statements. If you write a long line of code for anything but data (e.g. user visible error message is data and doesn't need to be wrapped – just write the whole error message on one line, please) you're doing something wrong. If you need to wrap your statement because it cannot fit on one line, that statement is trying to do too much to be both readable and maintainable.
    1
  229. 11:40 I don't think that "best programmers" always help others. I think it makes sense to help others if you think long term future but for short term helping other developers may just slow you down. If the "best programmer" is in the project for a short time (for any reason), it doesn't make sense to use that time to help and teach unless that was the whole reason the "best programmer" was brought into the team. However, even if you target long term, it might be that helping/teaching other members of the team is wasted effort because CEO might end up firing the person you just spent weeks to train. I like teaching my team members new skills but that's not without risks or side-effects.
    1
  230. 19:30 I agree. Always document any workaround in your code. Comments are the best way to do that because there's at least some hope that that documentation matches the actual implementation. Out of band documentation will never match the actual implementation in long run.
    1
  231. Great example about how theoretically best algorithm is not always the best with real world hardware.
    1
  232. 19:10 Open source developers also feel any comments about their code as personal attack. When someone starts to react to feeling of personal attack over the actual code and automation, you'll end up with bloody fights. And that was demonstrated here by the filesystem maintainer that really wants to use C only and totally ignore Rust. I guess he really assumed that he must learn Rust and maintain these Rust bindings in the future and he's aggressively trying to avoid that future right now.
    1
  233. I think ability to write thread safe code without race conditions is the most important feature of Rust and now safe C++ claims to have the same feature. Managed languages such as Java et al cannot guarantee race free multi-threaded coded and always depend on mistake-free developer (yeah, good luck with that).
    1
  234. I think any development method should be considered as guidelines instead of strict rules. Absolute rules are always a problem because any simple set of rules is never going to work for everything. I liked the star navigation idea. SOLID (or other methodology you try to follow) should be considered a rough target but if you hit a mountain, it's wiser to go around it than through it just to keep your direction perfect. Just make sure you make known decisions when you differ from your target method. You shouldn't make exceptions accidentally.
    1
  235. 20:05 And if you're writing really SOLID code, you wouldn't have a class than do both persistence to files and persistence to database, right? As a result, you immediately have to have some kind of interface class and then to implementations for it. Instead of writing two functions in a single class! Adding more flexibility does add complexity to your code. And I think every experienced developer would agree that additional complexity is definitely not what we want.
    1
  236. Programming is hard and interesting exactly because we have a moving target. Requirements change all the time and the underlying libraries and operating systems change, too. Any long term project is going to need a lot of change even if you don't pick up any new programming languages. And you should learn at least basics of many programming languages. I think most languages I've learned have teached me something that's worth using in other programming languages, too. For example, Perl makes using hashmaps and regular expressions really easy, Eiffel teaches you about Design-by-contract, preconditions, postconditions and design invariants. You can definitely use those some ideas in C++ and other low level languages. Rust is worth learning to make the ownership concept really clear. A well written C++ will use ownership concept all the time but the language itself doesn't support it like Rust does so you're on your own even though you have to embrace the ownership concept or you'll have broken memory handling in long run.
    1
  237. I never understand C++ naming in std namespace. Who thought std::views::iota() was better than std::views::range() or maybe even std::range::integer()?
    1
  238. 22:27 I would argue that Rust made a mistake when they ever added unwrap(). I think it should be called unsafe_unwrap() or something like that because well written code shouldn't use it.
    1
  239. 18:18 I think UML diagrams are one option for visualization of the code you already have. I have never ever seen a case where it has been a good idea to first create UML diagrams first and then generated code based on those diagrams. Whenever somebody asks me to create an UML diagram, I always generate it from code, even if I had to write the code just to generate the diagram.
    1
  240. 12:50 Offshoring is actually a great example of stuff that will cause problems if you try to implement the code with AI. If actual human developers offshore couldn't figure out your requirement/spec/instructions, what change does the non-AGI level AI have?
    1
  241.  @dmitripogosian5084  My point was that if you intentionally use suboptimal code for a given language, it's not a fair test.
    1
  242.  @dmitripogosian5084  When you use malloc() in C, it's not implemented in C but uses a syscall to request the operating system to do the heavy lifting. Do you think that malloc() shouldn't be used in C either? The function levenshtein() is a standard PHP function so if you decide to now use that you're simply intentionally writing inferior code. I guess you could also interpret this as "it's stupid to create benchmark using so simple algorithms that the algorithm could be part of the language spec for some language". That is, unless the whole intent is code golf and you want to show superiority of language such as GolfScript.
    1
  243.  @TapetBart  Interesting... I tried to look for some examples but ATS code seems practically unreadable for me so I didn't understand how the design-by-contract feature would work if that's indeed supported.
    1
  244. I would argue that xz was enabled by m4 scripting. That code is always so messy that nobody even tries to understand it so it's easy to hide anything there.
    1
  245. 56:30 I've been programming for quarter century and I'm trying to follow AI tools pretty well and I totally agree you here. Juniors should be training their brains instead of trying to be productive with currently available AI systems. Sure, it makes sense to test waters to understand where the AI is right now but don't assume that the currently required prompt engineering has value in 2 years. As long as AI can do the same tasks faster than you, it means you have to keep improving your brain, not that you should stop learning and try to be productive with AI. ChatGPT and Grok 3 are just additional tools that I use in addition to Google, Stack Overflow and other information sources. And I still have to verify all data from trustworthy sources no matter which source I use.
    1
  246. 53:40 My personal preference is no wrapping of lines but avoid long lines. As such, I wouldn't accept that 8 line long if statement and would want to see a function checking for those options instead. The only exception is that long strings should stay on a single line no matter how long those are. Splicing a single logical line to multiple lines in source code is just ugly. If the semantics are one long string, it must look like one long string in the source code, too.
    1
  247. 19:50 100% agree for explicit return! I even write the keyword return for my lambda functions just to make it extra clear what's happening.
    1
  248. Typically the system wide mmap max limit prevents running 100k threads by default on Linux. In practice you may need to adjust following settings: /proc/sys/kernel/threads-max /proc/sys/vm/max_map_count /proc/sys/kernel/pid_max And of course, you need 64 bit CPU and OS but I guess that should be default today.
    1
  249. Unpopular opinion: TypeScript is for people that cannot write good JavaScript code. Copilot may cover the same userbase.
    1
  250. I think gamification is good for figuring out which accounts are real users and which accounts are bots or spammers. The "reputation" (which I consider karma in reality) on StackOverflow gets you more admin tools once you demonstrate enough sensible behavior. For example, with my current reputation I could go around the site and modify the descriptions of all the tags and mess things out seriously bad. So I understand why those actions are not available to any random spammer. But I think it's a really good idea to give more admin-like powers to users of the site as long as they demonstrate behavior that aligns with the sites objectives. Other than the ability to do actions that are not allowed for newly created users or users with bad karma (e.g. spammers or bots) I don't really care about how much reputation I have. If some future employer were ever interested in that kind of statistics, sure, it would be nice to be able to show that I have this much reputation on StackOverflow. I still feel that the reputation is thanks to sensible behavior, not because I've gamed the system. Gamification results in some users primarily answering only easy questions that get lots of traffic via Google. I don't like that but I understand that it's good for the site because Google gives more value to StackOverflow pages if lots of users looking for simple answers click the StackOverflow page in the results. So even though I don't personally think those answers are worth a lot, I understand why even that kind of gamification benefits the whole site.
    1