Recorded live on twitch, GET IN / theprimeagen Original: • programming war crimes 1 Author: / @else1f MY MAIN YT CHANNEL: Has well edited engineering videos / theprimeagen Discord / discord
I used to be really frustrated with how difficult to understand academic papers are, but after gaining enough knowledge, I'm now a little more sympathetic - it's really easy to tersely express ideas with complex language, simplifying them requires a lot more effort and is almost always more verbose.
It would be nice if someone would keep a dictionary for all the field specific words that have quite precise meanings. That way ppl could reference that source instead of spending one or more paragraphs explaining a single word or notation. Or leave it as an exercise for the reader to figure out what something means. edit: before ppl explain the obvious fighting over the meaning of words this would produce, I know but a potato can dream.
It may be field specific, but I honestly rarely encounter papers, that are complicated for the sake of being complicated, as some kind of intelectual voyeurism. Most of the difficulty comes from not knowing the field, which cannot be easily overcome I'm afraid.
@@rumplstiltztinkerstein it's likely that until AI is fully self-explainable and deterministic society will continue to rely on human correction and oversight at least for success critical projects
One from my brother: Code purpose: Every time list is changed, sort list. Problem: sorting list counts as a list change, producing infinite recursion. Solution: catch exception when hitting max recursion depth, assume list is sorted at that point, and continue from where you left off. As he says: "if it works, it works!" [He did fix it the next day when he worked out the proper way to do it.]
5:31 For those wondering, this is Minecraft enchanting table language (aka Standard Galactic alphabet), which is actually not a language but just a font that looks all funky
i hate that it's known as the minecraft language, rather than the commander keen language. but i guess it's nice that some people might be led to discover commander keen throught it.
i wrote a JS "translator" for this once - it's actually comprised of unicode. what's worse is some ASCII chars actually are represented by multiple SGA chars which broke my poor virgin JS dev soul
I’ve done it ¯\_(ツ)_/¯ Back before I’d set my comment-block to the best ever keyboard shortcut (Shift+Alt+A) Protip: you can set a block comment shortcut in SSMS. Sadtip: you cannot use the same shortcut to block uncomment :( Mildtip: • (Shift+Alt+A)->block comment • (Ctrl+Shift+Alt+A)->block uncomment
i do that all the time in unity, all it does is ignore the function until i finish it so i can run the game, if that is at the end a jususst use return but some ides complain that there is code after the return
1:34 I actually did that recently. The stack trace sometimes contained personally identifiable information, so I caught and rethrew the error to get rid of it in our logs.
I've seen this one java class that had a 6,500 line method with 5 layers of inheritance. Stuck right in the middle of the method were these two massive nested if blocks where they both were ~450 lines of if, else if, else crap. Best part was the second of the two if blocks was a copy and paste of the first with one comment saying "don't delete this because for some reason the code won't work without it," and you know what that person was right!
On my first ever project that wasn't trivial I had a similar situation where I needed to add else if instead of else or the code didn't work. To this day I don't know why that was the case as it was supposed to be a boolean condition. Anyways, long ago I rewrote that entire part of my project, so I no longer have that issue.
I literally had seen code from a colleague with constants like this: int OneSecondWaitTimeout = 1; int TwoSecondWaitTimeout = 2; int FiveThousandMillisecondsTimeout = 5000; Not a joke, it exists and everytime I review code from this guy, I die inside.
I take it this was used one time in one file, but if any one of these were used in ~100 places across several files, it makes sense to capture it in a variable.
@@Asto508 Not local; global. That's what I meant with "100 places across several files". Magic strings and numbers are a major PITA. It's better to group them in one place and refer to them via constants or enums. If by your post you meant that your colleague keeps them _in one scope_ then yeah, that's dumb AF and I feel your pain; I get those as well. ``` const isLoggedIn = user.logged_in if (isLoggedIn) { ... } ``` _fukme_
@@Honken Well, if the constants are actually some very important number, then I can see your point, but we are literally talking about "1" or "2" in constants named "One" and "Two".
@@Asto508 The same principle still applies; if they are used hundreds of times, by having them constant you have one uniform value instead of hundreds of arbitrary values, hence the word 'constant'. If we need to change TIMEOUT from 2.0 to 5.0, that's a one line change. If we have to dig through tens of thousands of lines of code and find every `timeDiff.Seconds >= 2.0`, we will be wasting a lot of time and run the very palpable risk of missing one and heisenbug ourselves into pager duty on Christmas. As dumb as it sounds, having a constant/enum called One which is bound to the integer 1, if the references to that number is high, it's an investment well made.
Catching and then rethrowing immediately is useful when you need a debugger trap because breaking on exception sometimes destroys the callstack legibility, I'm looking at you javascript. And then you forget it and push it to production.
In the Java case, the debugger trap is useful as setting a breakpoint at the end of a function doesn't get triggered if the stack is being jumped/unwound. There may be advanced debugger features that can do this, but its much easier to combine basic debugger functionality with basic code and set a breakpoint on that line so you can examine what's going on as the exception is being thrown. A very similar (but not exact) reason to do this is if the caught exception is checked and you're just rethrowing an unchecked, or a different wrapped checked (ugh) exception.
@@drewbabe If it hasn't changed it's necessary in Java to catch exceptions (elsewise the code will not compile), if you can't handle them you have to rethrow them. Thus the shown code is the only valid way in Java to escalate the exception upwards into runtime. It's not cringe in anyway, not every exception can be handled by a program, but needing to handle all exceptions leads to more safe code (defensive programming). I mean Rust does pretty much the same thing with an onEvent function instead of a catch block and people praise rust for this. Just because it's older way, doesn't make it worse.
@@MrDavibu I don't see how putting it in a try/catch block would change anything in Java. I don't know if it was ever different, but when I've worked with Java the way it works is that a function can't throw an exception unless you include "throws Exception" (or some subclass of Exception) as part of the function declaration, and if you do have that included as part of the function declaration then you don't need to include a try/catch block even if something within that function throws an exception.
6:38 Experts, please explain to me the difference between a Git rainforest and a primitive Git jungle. What are the most toxic bugs that can be found in there?
Yesterday i was refactorig some code written by a collegue and i found this gem. $files = [ ] foreach ($media_files as $file){ $files [] = $file; } return $files; Also the most evil definition of true/false ive ever seen is #define true (rand() % 2) #define false (rand() % 2)
Making a copy of a list to avoid leaking internal state or reference issues has many valid uses. You probably broke your colleagues code and caused a disaster due to naivety.
@@gregorymorse8423I was about to say that, unless php has some function like Java to return a super fast copy of a collection instance, this is good/normal code.
One that always gets me: ``` if condition return true else return false ``` Or one where items were deleted from a collection in a set of nested loops and checks, e.g. ``` while true { for index in range { if (range[index] == itemToDelete) { range = range[0..index-1] + range[index..range.size] found = true } } if found break } ``` There are so many better options one can choose. One, assuming no need to preserve order or immutability is to reverse the iteration order and swap the found item with the last [unmatched] index and then just trim the collection to the new size.
@@Nathan-pl2cf You can still return directly with a double negation (e.g. JS) or type cast (e.g Python). If you can branch on a condition then you can also directly return a boolean representation thereof (true|false; 1|0; etc.) in most common languages. Personally I try to dispense with weak notions of type as soon as possible as these, in my opinion, are too frequently a source of bugs.
@@TheAndreArtus I agree, just wanted to point out that they weren't entirely wrong, depending on the language anyways. I would probably go with explicit casting over the ternary though.
When I wrote fizzbuzz for the first time I did it in Python in a way that you could pass the fizzbuzz function a dictionary where the keys are numbers and the values the strings to replace them with, so you could call it with {3: "fizz", 5: "buzz"} or {3: "fizz", 5: "buzz", 7: "bazz"} or whatever you like, with pretty much as big a dictionary as you wanted.
@@henry_tsai I think I described it poorly. You pass a dictionary with all the numbers. If you pass just {3: "fizz", 5: "buzz"} it will automatically replace all multiples of just 3 with fizz, all multiples of just 5 with buzz and all multiples of 15 with fizzbuzz. If you pass {3: "fizz", 5: "buzz", 7: "bazz"} it will additionally replace all multiples of 21 with fizzbazz, all multiples of 35 with buzzbazz and all multiples of 105 with fizzbuzzbazz. That is, assuming I added a maximum number parameter to allow it to output more than 100 numbers, which I don't remember if I did or not, and I don't know if still have the original code I wrote.
About sentered code - it is actually a thing that was popular back in the days where ide was not common an people programmed in simple text editors. Ive seen that myself but aside from how it looks it was pretty comfortable to read and there was no errors.
Sometimes at work (in Go) we write functions that take a pointer to a boolean as a parameter, usually for a simple filter that has three states (eg: when requesting customer list get free users / premium users / all users). Certain higher level functions always need a particular list, but you can't just pass true because it needs to be a pointer, so I call it like this: true := true myFunction( &true ) "If it's stupid but it works, it's not stupid." (/s)
For the FizzBuzz stuff, use a map with numeric keys and what should be printed. Use % key == 0, add value to variable and print at the end, printing the number if variable is empty. You're welcome.
What do you mean by " % key == 0"? You mean iterate over the key values and check if whatever number you have `% key` is 0? Then what's the point of having a map in the first place?
@@CottidaeSEA sure, but MH_VOID isn't using a map. That's just an array of tuples. Still, why would that be any better or worse than having just more if statements (presuming you do string concatenation)? I'd argue it's less readable unless you're getting into many more than 4 or 5 branches.
the thing is, the 'if/else' fizzbuzz solution is usually the most performant. It's just not scalable at all. Also if you add 'bazz' as 7 then would you also print 'fizzbuzzbazz' when the number is divisible by all of them?
It’s not the most performant. Use counters instead, which reset on hitting 3 and 5 and you remove %. Optimize it further and populate an array[n=smallest divisible number=3*5] with answers and write to output as many times as needed.
1:34 I have this in my code 😃 though I would say it's the most natural solution as I am writting a custom language compiler and when an error is thrown during macro expansion I want to log the entire macro expansion chain. (Like "missing semicolon", "note: in expansion of macro macro_2!()", "note: in expansion of macro macro_1!()" ...)
Here's my Fizzbuzz in Haskell I made while trying out Haskell, I'm excluding the tests, test harness, main IO function and combining it all into one file. I wanted to have a ruleset file that was the only thing you needed to change to add more rules like is commonly asked in the FizzBuzz toy problem. import Data.Foldable import Data.Maybe type FizzRule = Int -> Maybe String fizz :: FizzRule fizz = rule 3 "Fizz" buzz :: FizzRule buzz = rule 5 "Buzz" foo :: FizzRule foo = rule 7 "Foo" bar :: FizzRule bar = rule 11 "Bar" baz :: FizzRule baz = rule 13 "Baz" rule :: Int -> String -> FizzRule rule n m i = case i `mod` n of 0 -> Just m _ -> Nothing fizzBuzz :: [FizzRule] -> [Int] -> [String] fizzBuzz rules = map f where f i = fromMaybe (show i) (ruleset i) ruleset = fold rules
Can someone explain what he is talking about with FizzBuzz and a map? I understand a map as either a hashmap like a typical Javascript object or the Array prototype function map where you iterate an array an pass a function to run that takes each item in the array as an argument. I was trying to look up solutions to FizzBuzz that use a map (or Array.map) and I can't seem to figure out how that would make it more extensible or scalable that using if statements.
You are overthinking it! I initially thought the same thing but realized there are referring to "map" ( iterate n times and transform each value ). FizzBuzz is so Trivial that it makes it difficult!
Its the hashmap one. It seems overkill if you're only dealing with 2 or 3 replacements, but it shows that you could design a routine that might take maybe 30 replacements if you wanted without having to write a giant stack of if/else. Of course you can do that with just a bunch of single ifs (not else ifs) as long as you're careful to only print a newline at the end of them all, but the next question (to drive you to the "correct" answer) would be asking how the replacements could be configured / passed into the method externally rather than hardcoded. If they push you to the map solution (one way or the other), and you're sufficiently familiar with your language's data structures to know how to deal with it (because they'll obviously tell you to suggest an answer yourself!), you can ask if the order of the words matters. In most languages the basic map structure is unordered and since that's (usually) not the goal of the exercise the interviewer might not have been thinking about it (not that they wouldn't understand the question of course, just that it might not have been in their head at the time so bringing it up might show an extra layer of thought about the problem). Of course FizzBuzz is so well known its unlikely they'll push all that hard. If its used at all anymore, it'll just be as a basic filter problem and they'll focus on something more relevant (and less likely to have just been memorized from any of the million examples online).
@@TeslaPixel Uhh not much, I suppose. That wasn't really in the OP's question though. I was mostly distinguishing a hashmap data structure (which probably wouldn't be any better than the array of pairs) from a functional-style map() method (which wouldn't really do what's needed.. of course if you had a list of numbers you could map() them using a map :D).
2:00 this shit happens in java with its "checked exceptions", it means that you can't just don't write this catch block, if a method throws "checked exception". So, what people usually do in this situation ? They catch this checked exception, whatever type it is and then just do in catch block something like this: throw new RuntimeException(e); These checked exceptions are exceptionally annoying in lambdas, such as Runnable, Callable, Function and others. Because without this your lambda will be just one line(sometimes), but you have to specify this catch block there. Or, they can use their own type which extends RuntimeException. But anyway, this example just means no sense, because as I remember, Exception is a checked exception. So in this situation, they literally do just nothing.
I had to spend probably an extra week of effort debugging an application on a customer environment the dev team doesn't have access to because the application is riddled with exception catches that throw new exceptions everywhere so you can never figure out the full story and even with full server logs w/ annotated context and testing results the dev team isn't always sure what happened. I kept mentioning that it was unfortunate I couldn't know what the error actually was because of it. But instead of getting better, there were more catch throw new added and added. I just couldn't even anymore. Just couldn't even.
I think what he means with fizzbuzz and map and adding a 7 for example would be this: const condition = { 3: "Fizz", 5: "Buzz", 7: "Prime" }; for (var i = 1; i i % key === 0 ? value : "") .join(""); if (!answer) answer = i; console.log(answer); }
I have also done it in one liner (kind of): const conditions = { 3: "fizz", 5: "buzz", 7: "prime" }; for (let i = 1; i i % +key === 0 ? conditions[key] : "" ) ); console.log(line); } Or better to use an actual map here: const conditions = new Map([ [3, "Fizz"], [5, "Buzz"], [7, "Prime"], ]); for (let i = 1; i
@@twothreeoneoneseventwoonefour5 This is something i wrote quickly in the console and if its let or var here is so unimportant :D There are 1000 ways of solving this.
9:36 can smeone explain what he is talking about? As far as I am aware, you still need to use a number of if statements... Like the only thing I can think of that he might be talking about is creating an empty output string and then concatenating it with "Fizz" on 3 "Buzz" on 5 and "Bazz" on 7, which still requires 3 if statements. What does he mean by "anyting better"?
You can map an integer to a string. And then when iterating over numbers you additionally iterate over the map keys. This approach is slower but more "extensible". Slower because you have to jump around memory and cause a shitton of cache misses. Basically this is a shit question that depends on the interviewers interpretation on what is an "optimal" solution
1:35 this is a valid solution when you need to strip everything but the message string to avoid leaking sensitive data. It would be better to rewrite the error though. Bandaid foxes cost more in the longun.
I agree a lot of so-called geniuses to speak in a certain way that makes them seem smarter than they really are... Neil deGrasse Tyson being the main person I think about when I think about people who everybody thinks is a genius but just seems to be very assertive and talk in a very specific way.
From what I've read of N. D. Tyson, he's a lot smarter than you and I in astrophysics. But coders (I'm not one, at least one professionally) often do clever stuff like x += 1; rather than x = x + 1; just to show off methinks.
@@raylopez99 "But coders (I'm not one, at least one professionally) often do clever stuff like x += 1; rather than x = x + 1; just to show off methinks." bruh
@@raylopez99 a better example that is far less clear is in something like C, combining iteration and dereferencing in to an already dense bit of code. it's unnecessary and poorly breaks down the solution in to its meaningful parts.
const sentence1Array = ["There", "is", "a", "big", "problem", "with", "this", "video"]; const sentence2Array = ["It", "was", "too", "short"]; console.log(sentence1Array[0]); console.log(sentence1Array[1]); console.log(sentence1Array[2]); console.log(sentence1Array[3]); console.log(sentence1Array[4]); console.log(sentence1Array[5]); console.log(sentence1Array[6]); console.log(sentence1Array[7]); console.log(sentence2Array[0]); console.log(sentence2Array[1]); console.log(sentence2Array[2]); console.log(sentence2Array[3]); I had to fight with Chat-GPT, more than 5 prompts to force it to write the code in this way. But it didn't complain about writing it in JavaScript
I was so confused about how FizzBuzz can be done with a map. And after giving up and looking it up. It's actually NOT A MAP. Okay, it's specifically not a hash map. It gets converted to an array of conditions and each number is run through the array to see if it matches one of those conditions.
Uuhh, kinda in that first situation right now. Other than throwing a NEW exception, what is wrong with it if I absolutely have to handle the error (as in a specific error that might be thrown there) higher up the call chain?
You are buying nothing by doing that as its still the callers problem. You've added no information and added noise. If you were translating it to a RUNTIME exception or adding some contextual information to the error string it'd be potentially useful.
@@DagarCoH Sorry, i meant 'you' as anyone doing what was shown in the video :) It can be very helpful to report on other state at the time of the error for logging to debug it, even if you can't recover.
@@DagarCoH As long as you're doing _something,_ its justifiable (well assuming the thing you're doing is not in itself useless of course). Wrapping an exception to change its type or provide additional context is an extremely common thing to do. Its the rethrowing of the same exception without taking any other actions that's pointless. Actually as written, its somewhat dumber than pointless - its taking a potentially typed exception and wrapping it in a generic Exception. Just as useless as rethrowing the same one, but with the added bonus of shunting the actual exception information (including the exception message) one level down the cause/innerException chain and making it that much harder to find the real cause within the stack trace. Someone higher in the comments suggested this might be done to intentionally blitz the stack trace in case it contained sensitive information. That's a valid thing to do (though not really the right way to do it), but the code in the video doesn't even accomplish that task in any meaningful way: - If the logger fails to dig into the cause/innerException chain, then you've not only lost the original stack trace but also the error message, making the log message entirely useless. - If it does dig into the cause/innerException chain then you've accomplished nothing other than to make your log output longer.
I just paused the video at 3:20 and didn't realize for a full minute, because I was thinking it was already accidentally paused and tried to "unpause" it.
Yeah, this got me stumbled too. But apparently, he says "..what the maP is". Tbh, I don't know where map is useful in FizzBuzz, because all languages I know doesn't have map function in standard libs 😄.
I Personally had to work on refactor a program writtten in an ancient xbase derivative... Foxpro i think, that its function was to program production of bottled vbeverages on several produiction lines... the on-screen tables where bottle caliber and production line ID were cross referenced were made with HARDCODED ID ... I'm talking about 10 different calibers and 3 different production lines .... was a NIGHTMARE to get the business logic of all that spaghetti... Worst thing: I knew the guy who did it, and He always sold that chad "I Rule at coding BTW" vibe.... disgusting
The only reason why I don't fuck up with .sort() still to this day despite knowing this is that I implemented an O(n) heap-sort variant in the codebase and calling that anyways :D :D :D
6 месяцев назад
It's great that after 3 years in programming I understand every single joke. My wife looks at me like I am crazy.
I legit did the emptyString = "" yesterday 😂😂😂. I think there was a good reason for it though. I wrote a function that did a lot of string manipulation so I figured it would be better to read emptyString and space than to read "" and " "
I think that's a great reason. The true horror of defaultTrue, defaultFalse, and defaultEmptyString is not that we're aliasing easily-expressed values so much as that there's only 1 value of "true", "false", and "empty string" each, so there's no point in specifying a "default" for each of those categories
so, there are some programming languages developed exclusively to least ammount of characters code challenges, so they have some pretty complex semantics.
divisible_by_3 = lambda x: x % 3 == 0 divisible_by_5 = lambda x: x % 5 == 0 all_numbers_in_range_1_to_100 = range(1, 101) valid_fizz_numbers = list(filter(divisible_by_3, all_numbers_in_range_1_to_100)) valid_buzz_numbers = list(filter(divisible_by_5, all_numbers_in_range_1_to_100)) seven_map = {7: 'Bad'} for i in range(101): if i in valid_fizz_numbers and i in valid_buzz_numbers: print('FizzBuzz') elif i in valid_fizz_numbers: print('Fizz') elif i in valid_buzz_numbers: print('Buzz') elif i in seven_map: print(seven_map[i])
Instead of using a ton of if statements you can iterate over a datastructure. This allows you to add more cases that follow the same logic easily, and could even do it at runtime if required. Here's an JS example: function fizzbuzz() { const map = new Map([[3,"Fizz"],[5,"Buzz"],[7,"Bazz"]]) for(let i = 1; i
