adrianm

Alcubierre's drive is a solution to Einstein's field equations which simply means the math checks out in theory for warp drive.

The resulting practical problem is that the energy requirements necessary for the solution are far greater than what we can feasibly achieve now or in the future (exotic matter's existence notwithstanding).

But the fact that a physicist was able to derive this metric (energy requirements aside) is significant. Given the history of science, I would not discount the possibility that someone else will come along in the future with another solution which lowers the energy requirements to something feasible. But we can't predict this.

But isn't it amazing that the math checks out at all? I find it inspiring...

Wow, how did I miss javacpp? Looks featureful and actively maintained to boot. Thank you for these recommendations.

This is the interview in which Julian Assange may or may not imply this: https://www.youtube.com/watch?v=Kp7FkLBRpKg

You don't need a source for common sense. It will take years for self driving cars to become reliable. There are many adverse conditions the car will need to be able to deal with in the real world. Weather and all other chaotic systems are not to be dismissed casually if we want self driving cars to become a reality in our lifetime. Just because something will take a long time to reliably engineer doesn't mean it's not a worthy problem to solve.

I still want to understand what it means to be economically dialectical.

"Deng said he was proceeding in a dialectic manner economically."

What does this mean? Isn't dialectics a form of reasoning?

This is a really good post which contributes to the conversation. Why make it on a throwaway account? We need more of this here!

I understand that Raven's can vocalize, I am just skeptical of that original video you linked. I am just wondering if there was evidence that it was authentic since that Youtube user's videos seem to go so far beyond what I've seen Raven's do before.

I am skeptical of the specific video he linked, not of the well established fact that Raven's can vocalize.

Is there any evidence this isn't fake?

He was making a joke.

This article is a combination of hyperbole and speculation. Take the first paragraph in the section entitled "The CEO":

"After the massive success of The Empire Strikes Back, Lucas realized that he was making 3 times as much revenue in toy sales than he was for the actual films. Thus, if he could sell more toys, it would mean more projects for Lucasfilm, and even less need for studio financing."

Three paragraphs down it becomes clear that this idea originates in a quote from Gary Kurtz, whose context for these statements is left completely unexplained, leaving the reader to dig further. No evidence is provided to support the conclusion the author has come to and instead the author has inferred Lucas' motivations from the Kurtz quote almost verbatim.

This is but one example of this type of writing in the article. Every point the author makes is supported by similarly spurious reasoning. I suggest future readers to just give this one a pass and not make the mistake of reading something whose opinion you might already agree with and looking past its bad writing.

So according to this binary definition of free speech, what countries actually have it?

It seems like many countries have limitations on free speech, which according to this definition would mean they do not actually have free speech.

https://en.wikipedia.org/wiki/Hate_speech

This is a vast oversimplification of the problem. LLVM is a compiler IR; nothing more. It is not portable (you cannot generate IR for one target and have it work for another target) and it does not trivially map to the semantics of most languages beyond C.

A programming language is a combination of many components; assembly optimization and target code generation is just one important part of a much larger picture.

I'm only responding critically because I've seen this trope that LLVM is some sort of universal programming language target way too often now. It misleads people into underestimating the scope of the actual problem. LLVM is not a panacea.

If you really want to make your platform programmable from any programming language, invest time into a well designed C API. Your users will thank you.

China is virtually drug free?

In that case, Wikipedia could use your help cleaning up this and many related articles: https://en.wikipedia.org/wiki/Illegal_drug_trade_in_China

Don't forget to cite your sources! They're sticklers about that sort of thing.

You still deliver the mobile runtime as a static library, but the compiled library contains the entire LispWorks runtime minus the native code compiler (which is a constraint of the lack of executable memory on iOS). The runtime contains a byte-compiler however, so the runtime is still available intact in fairly complete form. You just need to make sure that CLOS and everything you care about for interactive development is kept during delivery (see the Delivery guide for details). How you deal with the lack of compile-file is up to you, (you can easily just treat it as a no-op, or a loader) but I personally installed my own function which remotely invokes the cross compiler to compile new ARM64 FASL and then save the results in a local directory on the iOS device. It will treat the code like any interpreted code, but it works great for development.

LispWorks' iOS mobile runtime can be used for interactive development. I use SLIME to develop with it myself.

If you mean Lisp as a straightforward expression of "Lambda calculus" then I would agree.

However, Lisp as in Common Lisp most certainly has a good amount of syntax. And let's not forget macros which amount to user defined syntactic extensions.

Here are some examples of syntax built into the standard:

Lambda lists have varying syntax depending on context. http://www.lispworks.com/documentation/lw70/CLHS/Body/03_d.h...

Declarations have both standardized and implementation defined syntax for introducing information into the compile-time environment: http://www.lispworks.com/documentation/lw70/CLHS/Body/03_c.h...

Type specifiers introduce new syntax for both standardized and user-defined types: http://www.lispworks.com/documentation/lw70/CLHS/Body/04_bc....

Logical pathnames: http://www.lispworks.com/documentation/lw70/CLHS/Body/19_ca....

Feature expressions: http://www.lispworks.com/documentation/lw70/CLHS/Body/24_aba...

And of course, programmable reader macros which is how syntax for every single language primitive in the language is introduced: http://www.lispworks.com/documentation/lw70/CLHS/Body/02_d.h...

Here's an example of a complex standardized macro with its own domain specific syntax (loop): http://www.lispworks.com/documentation/lw70/CLHS/Body/06_a.h...

Let's not forget that most of what one might think of as built-in features in Common Lisp are actually standardized extensions to the language built with macros.

All of the power, expressivity, and extensibility of Common Lisp is what makes it my favorite programming language. It's what makes everything like above possible and gives power back to the user. But ignoring the syntactic complexity will not win us any followers!

TLDR: Common Lisp isn't simple, but it exposes one of the most powerful and empowering programming environments we have.

Why is it technically illegal to download them?

The compiler processes byte-code as input, not Java source code. Therefore any language which can emit JVM byte-code ahead-of-time (AOT) should theoretically work.

Clojure, for example, permits AOT byte-code delivery of your project. So with a AOT compiled clojure.main jar on the class path, Clojure should theoretically work if you could interpret the byte-code at runtime as a fallback. In the absence of an interpreter, Clojure should also work if you do not rely on `eval` or any other functions which depend on the byte-code compiler at runtime.

This of course assumes their compilation model is compliant with whatever version of the JVM specification the Clojure compiler targets. IIRC it should be compatible back to Java 6, so Clojure might not work without some tweaks to this project's compiler.

(Disclaimer: I am not involved with the project.)

This is an argument for panspermia according to Neil deGrasse Tyson. (Real Time with Bill Maher, S13E29)

I find this slow march in "modern" language design toward completely static compilation models troublesome to the extreme. It feels like a significant historical regression; they speak as if Smalltalk and the Metaobject Protocol are things to revile and shun, not elegant programming models that we as programmers should aspire to understand and use in our own programs.

To elide these features as a matter of principle implies that you believe your compilation model is perfect, and is able to deduce all information necessary for optimal compilation of your program statically, perhaps augmented with profiling information you have obtained from earlier runs. It also makes upgrading programs for users more difficult since patches must be applied in a non-portable manner across programs. I shan't mention the fact that they make iterative, interactive development an ordeal. The Swift REPL is progress (although REPLs for static languages are nothing new), but it still pales in comparison to the development and debugging experience in any Smalltalk or Lisp system.

There is no reason why the typing disciplines Swift is designed to support should demand the eradication of all dynamism in the runtime and object model.

If you have never heard of the Metaobject Protocol or similar concepts before, here is the standard reference: https://mitpress.mit.edu/books/art-metaobject-protocol

This discussion also reminds me of this essay by Richard P. Gabriel: https://www.dreamsongs.com/SeatBelts.html

The game does not actually force you to replay old missions. You just have to complete certain side missions to progress in lieu of them. That confused me as well though - but I never had to complete any of those repeat missions and I completed the game. The game did not do a good job making that clear, however.

I would not call MGS5 an unfinished mess. I would call it unfinished, but that fact doesn't detract from it as one of the most innovative games I have ever played. I have never had the opportunity to truly "be" a character in a game before. When you're playing every mission in MGS5 - you are Snake.

You decide how every single objective is accomplished. Every mission can be played in a variety of varied ways. The fact that each mission felt so fluid and organic is a testament to the tremendous engineering and ingenuity that went into designing it.

Oh, but how I pine for the final chapter that could have been!

I encourage you to read Practical Common Lisp for an introduction to CLOS - the Common Lisp Object System. It's available for free online. (http://www.gigamonkeys.com/book/) If you are convinced that there may be something to object-oriented programming in Common Lisp that might be interesting and novel, I suggest two further advanced readings: Object Oriented Programming in Common Lisp and The Art of the Metaobject Protocol.

I use Clojure professionally, and CLOS is easily the thing I miss most.

How would TCO help? I've never read anything about the connection between TCO and persistent data structures. GC on the other hand is a known, and often assumed, requirement in the literature. Sounds interesting!

Common Lisp's foreign function interface (either implementation specific or cross-platform a la CFFI) allows for the explicit definition of how a foreign structure should be laid out in memory.

Even if I'm not using Lisp for the end product, whose SLA may not permit a runtime with garbage collection, I always find it invaluable to define low-level structures with a Lisp whose machine code compiler is available at runtime for experimental interactive development.

A free and open source Lisp that you might enjoy experimenting with is SBCL, available from http://www.sbcl.org.

Load up the REPL, and follow the manual available here http://sbcl.org/manual/index.html#Foreign-Function-Interface.

SBCL also allows you to interactively augment the machine code compiler, install new intrinsics, and disassemble any function interactively.

Even if you never use it for production code directly, it might become an invaluable tool in your low level development process.

Am I missing some critical source, or is this simply pure conjecture on the part of the author?

Not having those technologies but being captivated by the possibilities enabled by their existence is essentially what motivates many scientists. Instead of looking at it like a harsh reality, look at it like a grand challenge for yourself to be amongst those who contribute to their development (or provide the building blocks for later generations who do).

LispWorks has CAPI which is an incredible cross-platform GUI library which compiles down to the native GUI tookit of the host. It's fantastic!

http://www.lispworks.com/documentation/lw70/CAPI-M/html/capi...

I don't see a meaningful distinction between what makes a qrpff tie "art" and what makes calligraphic code "not art". He even named the piece aptly: "the most important algorithm that will fit on one page".