For what it's worth: it's _very_ rare for a type annotation to be required in Haskell. It's just considered best practice (supported by compiler warning options) to have them on all top-level declarations, for two reasons:
- it's a good extra layer of _human-readable_ documentation about basic behavior and requirements (as in this article); and
- it lets the compiler give better error messages.
The compiler is _always_ going to do its own inference, whether you give it a signature or not. If it infers a valid type _which isn't the one you thought you wrote_, and you didn't specify what the type _should_ be, that function/statement will compile -- you won't get an error until later, when you attempt to consume it and the types don't match. This can be harder to trace, especially if there's a bunch of polymorphic code in the middle where any type will pass. Supplying a manual annotation lets the compiler immediately say "hey, these don't match."
Einstein used the best tool he had at hands - math. Now we have mach better tools: computer models, knowledge databases, AI. Math is good because math formulas are very compact, so they are easy to play with, but computer models are much better, because computer can visualize them directly, calculate values correctly, and verify result automatically. Think about Computer Aided Science.
I'm confused - are you trolling us? You do realise that computer science is based on math right? All the calculations that that OpenGL does are mathematical calculations. Even databases are based on relational algebra. AI - linear algebra, probability, multivariate calculus, optimization etc.
There would be no computer science without math.
No, I'm not trolling. English language just have no word for that thing. How would you name something in middle of OpenGL, Kerbal, Wikipedia, Recursive Text, Alpha Go, etc? Something where you can setup your experiment, start it emulation, and then zoom from macro level to quantum level, with description of every effect at each level, with formulas at hand, with links to experiments, papers, reviews, confirmations? Something that can actually answer your questions, teach you actual physics. Something where you can plug your own theory to see is it fits real world better that someone else theory. I have no idea how to name it. Universal Programmable Augmented Disсoverable Science Model?
Exactly. And as many people appear to have turned on Trump online since the election, I've yet to meet someone in person that voted for him that is not a huge fan of him.
Frequencies are heavily regulated in the US as well. There are a handful of public bands, but anything else requires FCC licensing to use. Broadcast power is also restricted.
Of course, Germany could still be more restrictive, I don't know the law there! But there must be a fairly simple licensing path for some microwave bands, or nobody would be able to sell wireless routers. This is the same general class of equipment, so unless there's too much restriction on broadcast power to connect at kilometer+ ranges (with a focused directional antenna, rather than the broadcast antenna of a router!) there should be a way to make it work.
Not a physicist but I thought the Planck length specifically denies infinitesimality? And one of the proposed solutions to the black hole information problem is that due to local relativistic effects, they never actually reach singularity in finite time.
The Planck length isn't a minimum length or size, and doesn't have a whole lot of real significance other than as it results from a particular choice of units.
- it's a good extra layer of _human-readable_ documentation about basic behavior and requirements (as in this article); and
- it lets the compiler give better error messages.
The compiler is _always_ going to do its own inference, whether you give it a signature or not. If it infers a valid type _which isn't the one you thought you wrote_, and you didn't specify what the type _should_ be, that function/statement will compile -- you won't get an error until later, when you attempt to consume it and the types don't match. This can be harder to trace, especially if there's a bunch of polymorphic code in the middle where any type will pass. Supplying a manual annotation lets the compiler immediately say "hey, these don't match."