Comments by "xybersurfer" (@xybersurfer) on "Computerphile" channel.

  1. +magicstix0r with other words, you think that the brain's connections can be drawn on a big sheet of paper without overlapping lines (a planar graph). that's quite an assumption. did you read that somewhere?
    17
  2.  @DeveloperOfGames  no it's not
    10
  3.  @DeusGladiorum  JavaScript isn't higher-level than existing desktop languages though
    8
  4. i think a "Quant" is a person that models the stock market using statistics
    8
  5. it's an interesting topic. but i honestly think the explanation can use some work. some more examples showing the correspondence between proofs and programs would be nice (where all the steps are shown). i also don't think everyone is familiar with functional programming types and proof trees (so a lot of inbetween steps or transformations seem to be missing)
    6
  6. it's the truth though. Lambda Calculus is normally used, to formally explain how a function applied to some arguments, is transformed into a function with fixed parameters. it's basically just a way of explaining partial function application in functional programming. partial application is used all over the place in most functional languages. Haskell's "map" function is one of the best examples. it takes 2 parameters: - a function - a list if you give it both parameters, then it takes your function (first parameter) and applies it to each value in your list (second parameter). it gives you a list of the results. but if you only give the first parameter (fix the first parameter), then you get a "new" function. this new function takes a list (the remaining parameter for "map") and gives you a list of the results. Lambda Calculus could help you figure out what the input and output of such a new function is. but it is normally used for more theoretical things. i think functional languages have a huge advantage over imperative languages. you can quickly create more specialized functions, by just applying already existing functions on parameters
    5
  7. i bet it can worked out in a loop with the use of some kind of list
    5
  8. can you do recursion with the wheeler jump?
    5
  9. +StraightJacketRED i don't think it's related to the Monty Hall problem
    4
  10. i think that you don't need a definition for X. that's probably the wrong approach. the real problem is a lack of consistency, in the answers of these models
    4
  11. interesting idea but lots of information is missing. like what about: - performance of the generated code - dealing with bugs in the code generator - it's also not clear whether the mini language is declarative or imperative or whatever - how would this compare to manually written code that has all the rules properly separated from the presentation?
    4
  12. John Hightower it depends on the meaning you give to "This statement". let's call "This statement" "f(x)". then "This statement is false" is the proposition: f(x) = ¬f(x) then you can give it 2 interpretations 1. if "f(x)" is just a meaningless symbol to you, then you get a simple contradiction as a proposition: P = ¬P which simply has the value false 2. but, if you you interpret "¬f(x)" as the definition of "f(x)", then you get an infinite recursion. which computers have problems with of course: f(x) = ¬f(x) = ¬(¬f(x)) = ¬(¬(¬f(x))) ... etc in this way, the sentence "This statement is true" has the same infinite recursion problem because of self reference. recursion is supposed to have a decision about whether to continue or end (or it's just an infinite loop). computers have problem with it. because it does not make sense. the program is trying to do something with no hope of an answer. you can see it as computers having difficulty but you could also see it as us having difficulty telling them what to do (it's a blurry line)
    4
  13. very interesting how privacy pushes for more independence by running your own services and in a usable way, which i've always found an ideal to strive for
    4
  14. ALL ONE because the right side results in a function and functions take inputs. when not all inputs are given, then the result is a function that expects the remaining inputs (so functions can output functions). passing around functions like any other value is one of the strengths of functional programming ("normal" values are simply functions that don't take any inputs) technically these functions actually only take 1 input at a time (every lambda is the start of a function). so when you see 2 inputs. it's actually a function that takes 1 input and produces a function that takes the other input. this is called "currying"
    3
  15. if you agree with the basic rules of the system being true. then you agree anything built using that system being true. it's really that simple
    3
  16. no. you would have to create a proof to have a program (proofs are programs). and proving in Coq is much harder than conventional programming
    3
  17. i like the structure of Hutton's explanation. especially how he first introduces general recursion with rec f. but, he could have brought some extra attention to the fact that the result of rec f is a function. i think that this makes it extra difficult for people to understand (lot's of people confused in the comment section). working out the examples would have helped. on the other hand people might not really understand unless they come to the solution themselves. difficult dilema
    3
  18.  @codycast  you're wrong. this video makes sense
    3
  19. clickbait! next time actually show formal correctness
    3
  20. you can't program something to be sentient? not that i think it's sentient
    3
  21. the problem is when things break. that's the nightmare that people are much more likely to deal with. so it seems like a sound calculation. i would be less hesitant to apply updates given the right tools to rollback them back. also endless fixes, security or otherwise is a symptom of a deeper problem in the way develop software
    3
  22. wait for it to finish :p
    3
  23. well there's your problem. there is no such thing as absolute certainty
    3
  24. great idea. i would love to see an explanation of that thing
    2
  25. he talks about a computer without memory but presents a machine with state
    2
  26. isn't it a bit silly to draw lines that are not straight?
    2
  27. Anders Jackson i stand corrected. i agree
    2
  28. joselotl i think the guy in the video means that, in reality, those ranges are overlapping. but in the program, choices are made as to which ranges belong to which set. so if something is half dirty and half clean, the program will still decide whether it is either dirty or clean (but not both).
    2
  29. joselotl lol and neither do i. he seems to be doing things i would normally do anyway and it leaves me confused too. i'm guessing that his explanation is flawed.
    2
  30. TRUE = λx. λy. x FALSE = λx. λy. y NOT = λb. b FALSE TRUE AND = λx. λy. x y FALSE OR = λx. λy. x TRUE y
    2
  31. c# deals with types. but it does not directly deal with type theory. c# is weakly typed because because it is possible to get type errors at runtime. languages like haskell are strongly typed but they don't deal completely with type theory. languages like Coq and Agda deal directly with type theory
    2
  32.  @frilansspion  all Artificial Neural Networks. LaMDA (Language Model for Dialogue Applications) discussed in this video, is one of them
    2
  33. mrsuperguy2073 there are infinitely many whole numbers and we use integers to represent them. the number of bits is just a practical consideration. i think it's more about the length of the list than the numbers in it being infinitely large. not all lists have to containing growing numbers or numbers at all. similarly to the size of whole numbers, a list can be infinitely long but we use a data type to represent such a list. the amount of memory is also just a practical consideration. being able to directly represent an infinite list allows us to separate the definition of the list from the operations on it. in strict languages we would have to re-implement the same list along with different operations, everytime we would want to transform it. i think that being able to more directly express yourself and so not having to repeat yourself, makes it worth dealing with the practical considerations.
    2
  34. thanks. great video. i had to rewatch the previous one to get back up to speed, but it was worth it
    2
  35. and you are just existing in your lifetime. i'm not sure why you are so fixated on continuous processes
    2
  36. ​ @totalermist  it doesn't matter whether a function keeps running forever. a function can immediately return a new state on every call with which it can continue if called again with that state, all while that function is simulating another function that runs forever. in fact, do you know of any humans that run forever? do you think we stop being sentient if we were to become immortal? whether a function runs forever is a meaningless distinction
    2
  37.  @rosameltrozo5889  indeed. that sounds more like a bug
    2
  38. it still remains. the C compiler will describe how to create the binary file. the difference is that it's described in C instead of assembler
    2
  39. that almost sounds unfalsifiable
    2
  40. certee it never finishes sieving the infinite list because it is infinite. the result of sieve is a list with the first element calculated, and the rest of the elements are again a sieve result. the rest is a call to sieve waiting to be evaluated when you ask for the next element. you can stop sieving by not requesting more elements but this is different from finishing the sieving of the infinite list. it's more like "giving up" after you have the elements you want
    2
  41.  @YourTVUnplugged  that doesn't remove the need for pre-emption
    2
  42. Neil Roy no. in C, a string is just a pointer to a character. the characters are stored next to each other in memory (they are an array). to get a pointer to the next character you can increment the pointer to the character using: p++; or you could cast it into an array and use an index on this array, to get the character you want: c = arr[i] because arrays in C are basically pointers
    2
  43. debugging and stepping through code, is just one of the ways to maintain code. and already assumes a lot about the language. optimizing for maintenance is what's best. ideally debugging should be one of the last resorts
    2
  44.  @Wyvernnnn  i agree, but those rules should be broken to avoid diminishing returns. and i bet you are already breaking them for just that. for example: you probably wouldn't decrease code readability by 99%, to improve the user experience by 1%
    2
  45.  @Crazen2  but neural nets (like LaMDA) are not really programmed as a set of rules in the traditional sense, where the programmer has to think these up beforehand as you seem to be suggesting. the only rules such a program gets is a way of figuring things out and a set of data like conversation on the internet. whatever rules it figures out that makes the best predictions is what it's final rules are
    2
  46.  @davidwright7193  that's extremely low. but still whether a byte per record more would matter would depend, on the total size of a record. if 1000 records would fit then the size of each record would be at most 16 bytes. 1 byte would increase memory usage by at most 6.25%. i would be tempted to think that this percentage wouldn't make that much difference. it seems like you would always run into the memory limit anyway, with or without that extra byte. would these records be stored in a central system?
    2
  47.  @IceMetalPunk  it's not mandatory to call someone by their title. no work was invalidated here
    2
  48. cool. the game looks like V2000 for PS1
    1
  49. oh. haha. no wonder
    1
  50. Phaux and the lesson is: never use the equality operator to compare floating point values.
    1