• 0 Posts
  • 24 Comments
Joined 9 months ago
cake
Cake day: February 21st, 2024

help-circle



  • Short answer: Neural Networks and other “machine learning” technologies are inspired by the brain but are focused on taking advantage of what computers are good at. Simulating actual neurons is possible but not something computers are good at so it will be slow and resource intensive.

    Long Answer:

    1. Simulating neurons is fairly complex. Not impossible; we can simulate microscopic worms, but simulating a human brain of 100 billion neurons would be a bit much even for modern supercomputers
    2. Even if we had such a simulation, it would run much slower than realtime. Note that such a simulation would involve data sent between networked computers in a supercomputing cluster, while in the brain signals only have to travel short distances. Also what happens in the brain as a simple chemical release would be many calculations in a simulation.
    3. “Training” a human brain takes years of constant input to go from a baby that isn’t capable of much to a child capable of speech and basic reasoning. Training an AI simulation of a human brain is at least going to take that long (plus longer given that the simulation will be slower)
    4. That human brain starts with some basic programming that we don’t fully understand
    5. Theres a lot more about the human brain we don’t fully understand

  • I just looked it up and the $40 T-Mobile prepaid plan has a 10GB data limit. Tbh that’s probably plenty for most people, but it’s not unlimited. Their $50/mo option is unlimited, with caveats (such as throttling once you’ve used too much data).

    They are going to monitor your traffic and throttle based on estimated video streaming speed on any of their plans.

    Still pretty good compared to ATT and Verizon. Unfortunately I’m stuck with the provider I’m using since they seem to be the only one with good cover wage in my area.





  • The way you recover data from a totally dead drive is use a program that scans every byte and looks for structures in the data that look like files e.g. a jpeg will have a header followed by some blocks of content. In an encrypted drive everything looks like random data.

    Even if you have the key, you can’t begin searching through the data until it’s decrypted, and the kind of error that makes it so your drive won’t mount normally is likely to get in the way of decrypting normally as well.









  • Say I’m doing what you describe, operating on the same data with different functions, if written properly couldn’t a program do this even without a class structure to it? 🤔

    Yeah thats kinda where the first object oriented programming came from. In C (which doesn’t have classes) you define a struct (an arrangement of data in memory, kinda like a named tuple in Python), and then you write functions to manipulate those structs.

    For example, multiplying two complex vectors might look like:

    ComplexVectorMultiply(myVectorA, myVectorB, &myOutputVector, length);

    Programmers decided it would be a lot more readable if you could write code that looked like:

    myOutputVector = myVectorA.multiply(myVectorB);

    Or even just;

    myOutputVector = myVectorA * myVectorB;

    (This last iteration is an example of “operator overloading”).

    So yes, you can work entirely without classes, and that’s kinda how classes work under the hood. Fundamentally object oriented programming is just an organizational tool to help you write more readable and more concise code.


  • To add to this, there are kinda two main use cases for OOP. One is simply organizing your code by having a bunch of operations that could be performed on the same data be expressed as an object with different functions you could apply.

    The other use case is when you have two different data types where it makes sense to perform the same operation but with slight differences in behavior.

    For example, if you have a “real number” data type and a “complex number” data type, you could write classes for these data types that support basic arithmetic operations defined by a “numeric” superclass, and then write a matrix class that works for either data type automatically.