I love throwing that point at situations like this.
3,219 karma · joined February 7, 2015
I love throwing that point at situations like this.
That statement, while true, should anguish the heart of anybody in any way related to or concerned for academia.
For actual FLOPS/kW where the FLOPS matter, you still can't beat GPUs, or for non GPU-able code high-wattage high-performance CPUs that can chew through data like nobody's business. These low power systems' FLOPS take more kW in aggregate to perform the same work in similar ballpark times. But when things are I/O bound, the low power cores should be able to handle messages & transactions with much less wattage overhead than what the high single-thread performance CPUs have to spool up.
We're generally safe, but all the security organizations need to do something to justify themselves, and have ways of thinking that always pursues "greater security" as a direction even if it overshoots what is reasonable for free people.
When security begins to impede freedom, the mandate of security must be placed below the mandate for freedom. Security is there to protect freedom as its ideological basis, so this is an obvious prioritization.
Correlation is not causation. I could simply have been a time where the fear of flying grew staler than the need to fly/benefit of flying.
Australia, you fail at the very notion of free western civilization.
For instance, if you have an interlaced mode showing under a non-interlaced mode, then the entire screen displays at ~480i (to use modern terms) with the non-interlaced portion doubling its scanlines. But if the interlaced screen gets covered up, then it snaps to ~240p non-scandoubled.
The biggest modern problem with this is that displays turn themselves off to resync on mode changes, which always annoyed me greatly.
An emulation presents a replica of something else's outward observable behavior.
A simulation runs a specific internal model, which generates some gestalt behavioral results.
An emulator might simply mimic surface-level behavior directly, or use an internal simulation in order to generate it from first principles.
There really isn't a hard and fast agreed-upon definition of these terms in software, but these seem in tune with their non-computing definitions.
Some of the news-splashy C64 games being released are actually just ports that don't fully disclose their prior existence, and that kind of rubs me the wrong way.
There are namespacing facilities (though I'm not sure how far back in history they go) to discriminate your code's reach, as well as to import the public API from others' code, or in a different manner to bore into their private affairs generally for admin/debugging/tracing/modification. "Global" variables have thread-local, dynamically scoped bindings which are super useful for configuration, redirection, or setting other side-band broad context when calling into shared code.
Also it should be noted that these types of machines (at least from the Symbolics point of view) tended to be single-user workstations, though were still networked to allow remote (and simultaneous) access to its running world, with varying levels of per-connection context.
One of the biggest downsides of ye olde Lisp machines was garbage collection times. Some had facilities to define dedicated heap regions, but generally the GC had to walk the entire workstation heap across all "applications" in 1980s hardware, which wasn't great. But at least as a programmer, you could freely code and only worry about minimizing GC pressure when it became an issue, instead of starting from a required malloc/free perspective and constantly worry about leaks.
Since everything was Lisp all the way down, and Lisp is a very dynamic language, all calls that comprise the OS are available as plain function calls visible to the interactive REPL, introspection, and modification. They were very developer-oriented and had lots of ways to have live displays of objects, to reuse or interact with them, and very deep debugger and documentation integration, since all code was at the same "level".
Since it's a high level language that does not expose low level memory (although certainly there are obscure implementation-specific Lisp operations for doing so used deep in the guts), corruption of memory at a low crashy level isn't generally a thing. Protections between applications/processes aren't as necessary and it can all remain plain running threads & functions interacting with each other & the OS.
Where does the "harm" you talk about come from? Usually it's because there are other responsibilities you're engaged with. If you literally give everything else up to focus on one thing, these barbs aren't in your life. I'm talking forgoing rent to crash with family/friends, eating ramen, selling/getting rid of your things, live on credit cards, etc, and have a 24/7 focus that keeps you going.
You'd be surprised how much that frees you from the immediate "harm" you describe, but you also have nothing to fall back on, because you pretty much have nothing else anymore than your pursuit, and can be amassing enormous debt (financial and otherwise). It's a huge amortized, pushed-forward harm in the hopes that the gamble pays off. For many, it doesn't.
An easy example would be the Happy Birthday song.
Any other enforcements and punishments are overreaches by government on behalf of lobbying. Many agree that the scope and punishments on the books in the USA far outweigh the punished behavior, and these are being foisted upon the rest of the world in strong-armed multinational agreements, against the will of the people on the receiving ends.
The vast majority of languages are parsed into ASTs of some form, and Lisp is basically directly programming in AST data structures that are executable. Seeing that source code is basically just another data structure to be manipulated and converted was the major "Ah hah!" moment in demystifying compilers for me.
Forth is a great lower-level representation of nested expression evaluation, and sheds a lot of light on how to organize that evaluation in your code generation, converting foo(bar(baz(val),blort(val2))) into a linear stream of operations. Even for register machines, Forth's stack represents the intermediate values that must be retained between expressions in either registers or memory.
Once this basis of how programming languages work is established, then the ideas of new programming language design from the source code perspective can be explored in practical terms.
Net neutrality is policing specific legal vs illegal behaviors, similarly to environmental protection laws. A "free market" doesn't really (at least not publicly) allow illegal services, because the action itself is illegal, both inside and outside the market offerings, so it is relatively orthogonal.
Certainly the maximization of profit (which has little to do with free market operations, but more of lock-in) would be helped if they were freely allowed to pursue any illegal activity in the name of profit. But it is the realm of the government, not the market, to decide what should be illegal for everybody including market participants, to mitigate predatory actions and destructive externalities.
Natural language normally isn't a fully self-contained representation.
Stepping back a bit and simply looking at the context, though, it is an amusing contrast.
I find it amusing & ironic that they're pursuing games of efficiently & strategically killing enemies as examples of their successful progress. ;-)
Remember that the ocean is a soup of all of its inhabitants' excretions and decaying corpses, and happily consumes stuff like that. Ocean life thrives around raw sewage pipe outlets.