So we have two paths forward. One, we could try to influence the habits of billions of Internet users who use desktop-like web applications in an attempt to restore the document-based nature of the web; or two, we could provide an alternative to the artifice of modern JavaScript development which allows for better applications to be written and distributed to users that use and rely on them. The latter initiative is the more realistic and productive one, in my opinion.
WebAssembly will not lead to the end-of-times of the Internet as a content delivery vehicle. It is a net positive for the parts of the web that do not fulfill that purpose. If you're worried about the free and open web as a publishing platform, look more to governments and corporations around the world that collude to limit our freedom of expression (Facebook, we're all looking at you [3]).
[1] http://www.internetlivestats.com/internet-users/
[2] https://en.wikipedia.org/wiki/List_of_most_popular_websites
[3] http://www.theatlantic.com/technology/archive/2016/02/facebo...
This is probably the most true statement in your entire comment.
Running with the assumption that of course we should ignore the users who aren't "most" users (not a safe one).... I'd go farther, though. Whether or not these users are getting access to the utility they're looking for through:
(1) a web page with some layer of interactivity on top of more-or-less legible document semantics or
(2) whether they get it through a giant-blob-of-code SPA
is also irrelevant, right? Except to some minority of power users who can actually get more utility when someone uses a more basic semantic-document resource-oriented approach.
So it isn't the users who are driving the "let's use the web as a VM for desktop apps!" trend. It's the developers. And it isn't the billions of Internet users whose habits would need to change.
I'd guess the most ready response to this would be something like "How would you have the current Facebook/YouTube/WebMail Experience without this Desktop-Experience-Focus?" But as far as I can tell, the essentially utility involved here -- and to a large extent, the best things about the experience -- haven't really changed since a FB page was actually a legible document (a milestone we left down the road a looooong time ago).
The document-centered approach does have its limits. There are some applications it will not support. First-person shooters.... sure, deploy a black-box binary to a runtime.
Facebook, YouTube, and web mail are not really in that category at this point, and developer choices are the primary thing driving the march away from documents here.
Really? I was in a public middle school this afternoon that, just a few years ago, was having to buy expensive computers and licenses for MS-Word. Only a few could be bought, and each was its own little separately licensed, separately maintained world that easily became unusable. If a server had problems, your work required access to a specific machine. Access required lots of waiting.
And now? Chromebooks for a tenth the price (don't have to support full, expensive Widows/OSX), which they bought in order to "use the Web as a VM for desktop apps" (the horror!) such as Google's free equivalents of Word, Excel, and PowerPoint. Now everyone gets access, and they can even continue working on their own documents after school from the public library, a home tablet, or any number of other options made possible by the Web (and ever-improving hardware options).
And do you imagine that our science teacher and her students are more interested in A) "pages" about physics with "more-or-less legible document semantics", or B) live physics simulations to experiment with on their Chromebooks and phones? Are uncaring developers the only ones driving these poor users to the latter?
The problem with this "apps are oppression, simple docs for the masses!" meme is that the narrative excludes a vast number of those "underserved" who want good apps more than simple docs and need the Web-as-VM to finally make it possible.
They've been sold the idea that web apps and the cloud are beautiful and "free".
how did the developers force that one upon you ?
Now things are different.
I kindof knew someone was going to confuse my argument and think I was arguing against web applications. Or against the browser as a platform.
It's a sign of how deep a certain kind of thinking goes in the industry. If we're talking orienting around semantic documents and resources.... we can't be talking about real applications! There's just no way to create interactive applications around those!
(And conversely, unless we're talking about application frameworks, lots of code --preferably not written in JavaScript, of course, which everyone knows isn't a serious language compared to Python -- unless we're working with GUI toolkit metaphors, unless the finished product simply isn't meant to ever be read by a human, we can't be talking about an actual application, right?)
> And do you imagine that our science teacher and her students are more interested in A) "pages" about physics with "more-or-less legible document semantics", or B) live physics simulations to experiment with on their Chromebooks and phones? Are uncaring developers the only ones driving these poor users to the latter?
Like the astute reader would note I said in my earlier post, some applications really don't fit inside a document/resource-oriented paradigm. Some simulations for sure, including first-person shooters and other games.
Other simulations, of course, fit rather nicely as a document with a layer of interactivity, and in that case, yes, the problem would indeed be uncaring developers. Perhaps particularly those who think interactive and semantic are exclusive.
And I for one, can't wait to piss on Javascript's grave.
The web is just a worse experience of what Xerox already had.
(And what advantage does WebAssembly have over Java applets? We've been down this road.)
In another 20 years time, we might be at the level of productivity we had 20 years ago with VisualBasic.
You say that webdev is Applet 2.0? ok sure, at least it's open and moving instead of EOL'd [1] and the experience is better else wouldn't we all still be using Applets...
[1] http://www.v3.co.uk/v3-uk/news/2443810/oracle-signals-the-en...
Applet 2.0 was Flash, followed by Applet 3.0 aka Silverlight, followed by Applet 4.0 aka ecmspriten/asm.js.
My point is we could've embedded JVM in the browser "correctly" instead of reinventing the wheel with another byte code format.
They used syntax trees of program as a distribution format, compressed these trees with LZW variant and executed using simple JIT compiler (basically, tree automata over program trees). The size of Slim Binaries was smaller than JAR files for comparable Java programs. I don't remember exact percentage reduction, it was about 20-40, I believe.
Not all intermediate representations are bytecode.
Oh, and I think in webdev, there is a lot of... err... modern creative and innovative guys and gals out there who are always happy to rewrite the world again, because the last week's tech isn't cool anymore.
Has the Java world come up with anything better than Swing or SWT? Because those are the libraries that are in the "stable ecosystem with 20+ years of engineering behind it", and they are terrible. Give me the 'innovative' webdev guys and gals any day.
It has a XML/CSS based way to describe the UI/layout and then lets you link that to your code with annotations. It's not perfect, but it's a lot more pleasant to work with than the likes of SWT.
well said
Good luck getting Visual Basic adopted as an standard ;)
I am really happy that our current customer projects that I am involved with, are all native mobile and desktop applications.
(Hey, MS employees reading this - now VS Community is free-for-commercial-use, if you want to capture the 5<=revenue<=50 MM market, replicate the Delphi + VCL ecosystem for RAD apps with Azure as the backing technology. Lightswitch already let me target WPF and HTML5, with Xamarin you now have native mobile. You pushed for an "integrated" desktop + surface/tablet + cell-phone a few years too early, but Xamarin as the presentation layer and Azure as your data-store and you've got the feature set that most businesses need. You'd put me out of business, but absolutely take over that mid-market share.)
[0] Pedants, I'm one of you. No Coq was not used in this project ;) [1] http://blog.matthewskelton.net/2012/01/29/assert-based-error... Similar to this [2] http://janvanderhaegen.com/2015/01/14/its-2015-and-lightswit...
Someone try to do that with WebKit:
The same advantage as Javascript, I'd assume: easy access to the DOM and the concomitant natural integration into a webpage. Java applets were like a portal into a weird world that started with a security warning and all of the widgets looked wrong.
Do people actually read docs any longer? https://github.com/WebAssembly/ has some, my blog covered the 1VM requirement. There won't be a new "sandbox". JS and wasm interoperate over shared objects.
No, not really. People read headlines and make pithy middlebrow comments. Though I also don't think that's a new phenomenon...
It will happen...
> And what advantage does WebAssembly have over Java applets ?
Microsoft supports asm.js.
Not java.
Plus minified and obsfucated JavaScript is already quite common. See closure and asm.js.
And I agree that modern minified, packed and obfuscated JavaScript is also more like a binary blob than source code. WebAssembly is just a logical conclusion of this.
I think they failed because they were closed off, and nobody could read the shitty code, so people wrote shitty code. If we have things open, it gives people an incentive to make it look/work nice. Sure, not everyone will, but it makes it easier to shame those that dont.
People on HN seem to discount how absolutely amazing it is to have a VM that can almost seamlessly connect to a network and pull down awesome programs!
We already got DOS, Linux kernel, Window 95 running in the browser as very cool demo projects.
Maybe Angry bird Apk running unmodified inside browser at close to device speed would be next?
Except for, security constraints, currently require that APKs are packaged as Chrome extensions, and can't be served from web directly.
or apt-get, yum or pacman...
We all know how this story ended last time. And yet, here we are watching it all over again and most of us are powerless to do much about it. For all the superficial openness of the modern Web, the reality is that it is now utterly controlled by a small group of browser developers, a small group of centralised content hosts, and a small group of curators, several of which overlap with each other but almost none of which have goals that necessarily align with those of either the average web surfer or the average small content producer.
If the group is small, it's mainly because the job is very difficult. All browsers are a big mess and it takes time to be productive.
The idea of asm.js is one of Alon Zakai. He explains on his blog all the experiments he made before concluding with that.
A quote from the oldest post I know about emscripten:
"I want the speed of native code on the web - because I want to run things like game engines there - but I don't want Java, or NaCl, or some plugin. I want to use standard, platform-agnostic web technologies."
http://mozakai.blogspot.fr/2010/07/experiments-with-static-j...
Maybe Servo?
The more comprehensible browser codebase I know is Dillo.
I liked a lot Java Applets. It was fantastic to be able to draw pixels or use a toolkit in a web browser at that time.
I gave up Java near after the dispute between Sun and Microsoft about J++. Java was far less interesting for me without that feature.
It didn't get much traction because nobody really wants to program in Java on the client if there are alternatives.
Java is not the best (though it's better than JavaScript, and android contradicts your claim), but JVM bytecode as a target is great.
WebAssembly will have several actual competing implementations, not to mention that it's a drastically smaller addition to the existing Web platform.
The goal of WebAssembly is to open up the reach and easy user experience of the web browser to new types of applications that just aren't possible to build efficiently with current tech.
We're also making sure that wasm is a first-class citizen of the open web: see, for example, our thoughts around ES6 module interop, GC + DOM integration, and view-source to see the textual encoding of wasm [0][1].
[0]: https://github.com/WebAssembly/design/blob/master/Web.md
[1]: https://github.com/WebAssembly/design/blob/master/TextFormat...
(Disclaimer: I work on V8.)
I'd much rather see that time on current tech spent on harnessing the tools we have right now better, rather than new pie-in-the-sky tools that bring a host of disadvantages, such as being yet another jit language which resembles a processor from twenty years ago. With an MVP that doesn't include multiprocessing, doesn't include SIMD, etc, I fail to see how this is really better than the status quo.
I think you didn't read our FAQ or other site docs, and just assumed the worst. Why is that?
How do you pay publishers on sites that aren't partnered with you?
8. How do you use Bitcoin (BTC)?
We’re still developing the system, now entirely in the open source on github.com, but at this point we know we will use BTC only for permissionless payment delivery to user and publisher wallets that we will create using BitGo’s APIs. We hope to keep funds in BTC only in monthly payment buffers, to reduce effects of volatility. We intend to let expert users “bring their own BTC” to self-fund their wallets and auto-micropay for as much of their browsing as they like.
See also https://www.brave.com/blogpost_2.html which discusses user and publisher wallets. We'll have more in a week or two on the Brave Ledger payment system.
First-class function is not bad for 1995.
On the downside: Type coercion is always a bad idea. There is an inconsistency between built in types and user constructed types. It has terrible standard class libraries. It is verbose.
But I can name half a dozen other languages that suffer from these problems and more. Judicious use of a transpiler (like coffeescript) and choice of third party libraries will go a long way. Personally, I enjoy working in coffeescript more than Ruby specifically because of the first class functions.
Not the best programming language in the world, but not the worst either, IMHO. It's just unfortunate that some of the more obvious shortcomings weren't fixed early on.
https://en.wikipedia.org/wiki/Timeline_of_programming_langua...
That all said, WebAssembly is potentially an avenue to break that monopoly, and I do give him credit for seeking to address the issue.
And despite being an (awful) plugin with an IDE that cost $600, Flash won in the pre-iPhone/V8 era.
They all started from a similar position, JS wasn't a standard from day one, there's a reason why it's emcascript today.
> And despite being an (awful) plugin with an IDE that cost $600, Flash won in the pre-iPhone/V8 era.
That's laughable, what percentage of the web ran on Flash in 2007, 1%?
No, Javascript had the huge advantage of being first; it's the only one on your list that both wasn't a plugin and was supported by IE and Netscape. And yes, modern Javascript is a better technology than any of those, although that's really damning with faint praise.
If Netscape Navigator 2 had shipped with, say, a Perl VM in addition to the Javascript VM, then I can guarantee you that everybody would've written their scripts in Perl instead of Javascript.
>That's laughable, what percentage of the web ran on Flash in 2007, 1%?
Back in the day, the only ways you could write a web app of any complexity/performance were to either use Flash or do it serverside (remember – not long ago! – when the new hot web technology was Ruby on Rails? Remember when it was PHP?). Flash was the only option if you wanted video (well, it or something truly evil like RealPlayer) or if you wanted a consistent and appealing look for your site.
Flash was on 56% of all websites as of 2010: http://www.stevesouders.com/blog/2011/04/05/http-archive-url...
Google trends for Flash vs. Javascript in the SF Bay Area: https://www.google.com/trends/explore#q=%2Fm%2F02p97%2C%20%2...
It shows. JavaScript is fucking horrible, to put it mildly.
If you don't respect the founder of JavaScript and Mozilla, your standards are very high. I doubt many people commenting here would meet them.
There was already a better open-source web rendering engine and browser at the time. Maybe we'd've got a KHTML-based browser on Windows much sooner that would have filled the same role.
Mozilla is pretty cool I guess, JavaScript is pretty cool I guess. It's all really just whatever and I think he was very much in the right place at the right time for a lot of this, not that he isn't a brilliant man who's obviously far more accomplished than me.
But I think you're completely right. We took all that made the web unique, and turned it into a black box for abstracting away hardware/OS.
It's hardly surprising though... you can decentralize a network, but power and control over the medium was bound to become centralized in some form.
[0]http://www.smithsonianmag.com/ist/?next=/history/what-the-lu...
"The British weavers known as Luddites, who destroyed looms precisely 200 years ago, thought rising unemployment within their ranks was due to machinery. But there’s a case to be made that inflation, money supply expansion, budget deficits and trade barriers were equally to blame.
... [The] overall picture was of cheap money leading to labor-saving capital investment, while wages were eroded by inflation and economic activity was dampened by restrictions and excessive government deficits.
The Luddites have been mocked for attacking the productivity-enhancing machinery that was to improve living standards unprecedentedly. But given the economic policies of the time, which bear an uncomfortable resemblance to some of our own, the Luddites were right to believe that only higher unemployment, with no discernible improvement in conditions on the horizon, was their fate."
http://blogs.reuters.com/breakingviews/2011/03/11/were-luddi...
Were Luddites the victims of 2011-style finances? | By Martin Hutchinson | March 11, 2011
I stand by the rest of what I said though... I think we need to be mindful not just of where society is headed, but what kind of society we will live in when we get there.
Technology is important, but it's society that separates utopia from dystopia...
The silos exist today, facebook platform etc. Despite how hard they tried, they did not take over the web.
What does it matter what is the norm? Static HTML/CSS is going nowhere, you can still create static content, as you well know (IIRC you run a static blog). The improvements to the dynamic side of the web do not come at the expense of the document-oriented side, both currently coexist and I see no reason why making the dynamic side faster will change that.
Furthermore, changes to dynamic content can enhance the functionality of the document-focused side of the web. Consider Wikipedia. In some ways a Wiki is a set of documents, but it's a set of documents that grows based on utilising input from those using the service, democratising the accumulation of knowledge. For all its flaws, I can think of no other resource that better embodies the virtues of the web than Wikipedia, and Wikipedia would not have grown to the size it is now without the technology that supports web apps.
That said, I don't agree with the trend for moving everything to the cloud, and I hope we can see that trend reverse with better tools for people to take control of their own data. If more people had cheap home servers that were easy to maintain then the issues surrounding lack of control should be greatly reduced.
Not all data is open, that is unfortunate, but realistic. At the same time, huge amounts of data is open and available without an app.
What is the use case where we lose to something because of native performance improvements in javascript?
Anybody who wants to build a simple static site can still do that, and I'd suggest the majority of the web is still just that, or very close to it.
I really don't understand your comment about 'executables that only run as long as you are on a page'. You can only read content as long as you are on a page as well. Or are you concerned about our ability to do search and data-mining on large volume of available data?
The web succeeded in part because it was possible for anyone to do "view source" and see what was going on under the hood.
Having that source available is also an important aspect of software freedom.
Losing all that--especially the freedom to see exactly what your browser is executing--for a slight speed increase is ludicrous and I'm very, very sad to see this is being taken so seriously.
We had a huge opportunity here to shape an open and free web. Turning the web into nothing more than a binary distribution platform will undo decades of work and we may never again find ourselves in the lucky confluence of economic prosperity, technological advancement, and governmental benign neglect, that made the open web possible.
Interactivity is an increasingly important aspect of media and of our culture. People spend more money and time on games than on movies and TV.
I just don't think this is what we had in mind when we heralded the birth of the www.
It's never like the framers imagined. It's always stranger and more wonderful than they could have imagined. (And horrible in some ways they couldn't have imagined.)
Sure. But don't despair, because this future isn't as bleak as you'd assume. With things like Hoodie[0], GunDB[1] and other amazing bits of technology, we can keep the benefits of web-tech for application development, but allow the user to own their data still. Offline-first, easy sync when needed. And really, anything more complex than delivering static HTML pages has the downsides you're mentioning, so unless you want to live in 1995 I can't really understand it from a practical perspective ;)
[0] http://hood.ie/
Now the page is a blank template that will fill itself in using a bunch of under-water calls to the server. Those under-water calls are the result of running a bunch of code and that code will sooner or later end up being written in web assembly and will be mostly opaque.
It's just like those flash only pages of old.
And really, who cares about copy/paste, accessibility, fair use, user stylesheets, or any of that, when you could trade it for more resilient advertising? Not publishers, that's for sure.
It's going to open the floodgates to a new generation of those crappy bundled-up Flash websites that gave you very limited ability to interact with their content.
There are of course better things to do with it, but from my limited understanding of WebAssembly this is my biggest prediction for what it'll get used for.
You say that as if it was a bad thing. There is two kind of content (relevant to this diacussion at least) that get served trough the web - documents/media and apps. DOM/HTML is ok for the former it's a horrible hack in the latter and most of your objections to custom gui also apply to DOM gui frameworks + they are dog slow and annoying to use. There is room in the middle (webapps) but there is definately a class of apps out there that just don't fit in to the DOM/HTML and get zero benefits from it outside of delivery which is why they get done that way.
If a promising technology has a high likelihood for serious abuse but also a highly desirable upside, instead of tossing the baby with the bathwater, we should preempt the abuse through culture, policy, and possibly engineering.
Somebody's going to write a DOM-replacement page layout and rendering system, other people are going to adopt it, and we'll have to go through another whole phase of
"Guys, we made this shim layer that will make your website compatible with screenreaders and HTML5 semantic tags again!"
"I dunno, that sounds like work. And people could copy/paste from our articles? I'll pass."
<5 years later>
"The new version of PageRenderingFramework natively supports screen readers. Can we maybe make your content accessible to non-visual browsers now?"
"Yeah, I guess. We'll install it next time we rebuild our website."
On the plus side, I think most websites have outgrown the autoplaying music, so maybe we'll skip that part in this cycle.
That's exactly how we need to judge any important technology. This is a basic part of making things that "fail safely".
its technically difficult enough that I think its main use case will be for somewhat large and well funded companies that have the budget and expertise to deliver a fairly complex client side app that has behavior and design that is not easily done in existing web technologies.
for example, all the stuff that people attempt to do now on HTML canvases seems like a likely candidate to be replaced by web assembly apps. this could lead to an era of high performance streaming apps with pretty impressive graphics capabilities. basically just a huge upgrade to emscripten, right?
I'm just not seeing this as being a real threat/competitor with traditional document based content on the web. I don't think that's going anywhere and I don't think web assembly interferes with that on any significant level.
Because by definition if it is constructed with JavaScript it is neither fast nor secure.
I don't think this is doom and gloom for accessibility, though. The future is in general-purpose assistance technologies that mediate any application. You can smell it with the new work in ML. It is not here now, but as with everything in technology, by the time it's mature and widely available, it's nearly obsolete.
This only works if you're facing away from your destination.
I'm with you and actively avoid any remote SaaS for this reason, discussed at length here[2]. I don't care about the recurring fees, I'll pay them no problem as long as I can run the binary locally, so I can hedge against the acquire-hire-kill by AppleGoogTwit. When that happens not only do I risk losing data, but I risk losing a tool I depend on within my workflow. If my data has even a remote chance of being locked into a specific platform, i.e., if I can't host it Atlassian style[3], I'm not going to use it. This could rapidly turn into a bunch of mini-App Store instances -- where good apps and/or information disappear on a whim of the developer because they're tired of working on an Angular base. Not only does your data live in a walled garden, but you also risk being the unfortunate victim of the Bored Developer Syndrome.
Side-note: Most of the good engineering blogs I read are just stock WordPress themes with RSS enabled. None of that "RSS only the first paragraph so I get more hits" junk. If someone's intentionally silo'ing their data, more often than not it's one of those "4 things you didn't know about Bash!" blogs. Not much value when you can read the GNUinfo docs on it.
[1] I'm presuming you mean, in the sense of actually re-producing off the master tracks, not just EQ'ing [2] https://news.ycombinator.com/item?id=11250108 [3] https://news.ycombinator.com/item?id=10753650 - Paragraph 2
It could destroy the web and something new could emerge. Something simple and open again.
The web of today is like the X protocol in 80s. Too much sophisticated and very hard to implement. VNC can be seen as a replacement of X. Simpler and better in many aspects.
wasm can fail too or have a limited success like webrtc.
In a world full of robots, markdown is enough to render most contents like JSON is better than XML.
I'm a fan of Gopher and Wikipedia mobile.
http://gopher.floodgap.com/gopher/gw.lite
https://en.m.wikipedia.org/wiki/?mobileaction=toggle_view_mo...
HTML and CSS are not bad. The problem (for me) is the lack of diversity in the layout engines. It can be explained by the complexity of the standards. It's near impossible to create a new browser from scratch (that can display modern websites).
BTW people can't choose something else because there is nothing else and every computer has a web brower. It's more a monopoly.
I know there are a few of you x-bloggers here: I loved the time when I could find lots and lots and lots of technical stuff in a never ending web of blogs. Not everyone agreed but we linked back to the ones we disagreed with without caring about SEO.
Hey, we could event do web rings and RSS and and and...
Edit: There is still a lot of content, I just miss the time where everyone blogged and I wish we would decide to go back, and then do it.
What is the difference between serving HTML/CSS/JS to the browser, and some other stack of UI and algorithms?
If you're really so passionate about static content why not be part of a project to that aim? You can host a Gopher server and publish to it, it's stunningly easier to do.
Or maybe an alternative that runs on https? I'd be interested in that personally.
And the benefits of having source are overstated.
I didn't learn web programming by looking at other people's html and javascript. There was a little bit of that but most of the learning is from tutorials and books and experimenting.
And in the old days of C programs delivered as executables, were people unable to learn how to program in C?
Finally, WebAssembly is not a replacement for JavaScript but fills a gap that JavaScript can't (really fast code).
WebAssembly is basically a compiler target for C-like languages, which means that it's dramatically more expensive to "write" WebAssembly code than it is to use JavaScript, so people will only reach for it in cases where there's compelling reason. It'll never be a default choice for writing web apps.
Why? Won't any javascript (or any other source code) be compiled to webassembly before going to production?
Compiling JavaScript to WebAssembly can't be done as a simple compilation step, at least not with fast results - you really need a JIT or multiple JITs. In other words, you'd need to compile a full JS engine to WebAssembly together with your code.
> "Binaryen" is pronounced in the same manner as "Targaryen": bi-NAIR-ee-in. Or something like that? Anyhow, however Targaryen is correctly pronounced, they should rhyme. Aside from pronunciation, the Targaryen house words, "Fire and Blood", have also inspired Binaryen's: "Code and Bugs."
https://github.com/WebAssembly/binaryen
Do you know XZ Embedded?
http://tukaani.org/xz/embedded.html
I wonder if it could improve startup (with emterpreter?).
It reminds me encode.ru :)
Do you know the size of the compiled code?
Btw: the author's blog talks about LZHAM quite a bit http://richg42.blogspot.com/
edit: Looks like it's up to 190k
Compression Compressed size Decompresser Total size Time (ns/byte)
Program Options enwik8 enwik9 size (zip) enwik9+prog Comp Decomp Mem Alg Note
------- ------- ---------- ----------- ----------- ----------- ----- ----- --- --- ----
lzham 1.0 -d29 -x 25,002,070 202,237,199 191,600 s 202,428,799 1096 6.6 7800 LZ77 70
xz 5.2.1--lzma2=preset=9e,dict=1GiB,lc=4,pb=0 24,703,772 197,331,816 36,752 xd 197,368,568 5876 20 6000 LZ77 73
gzip 1.3.5 -9 36,445,248 322,591,995 38,801 x 322,630,796 101 17 1.6 LZ77I ran a quick with the tool (xzminidec) that comes with XZ Embedded.
gcc -O3 -s -D XZ_USE_CRC64 -o xzminidec xzminidec.c xz_crc32.c xz_crc64.c xz_dec_stream.c xz_dec_lzma2.c
du -b xzminidec
19472 xzminidec
ldd xzminidec
linux-vdso.so.1 (0x00007ffe9905c000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f105c83b000)
/lib64/ld-linux-x86-64.so.2 (0x000055d818666000)
du -b enwik8.zip
36445475 enwik8.zip
du -b enwik8.xz
26375764 enwik8.xz
time unzip enwik8.zip
real 0m1.023s
user 0m0.948s
sys 0m0.068s
time cat enwik8.xz | ./xzminidec > out-xz.txt
real 0m2.598s
user 0m2.504s
sys 0m0.136s
cmp enwik8 out-xz.txt
(empty)
unzip is faster but the xz decoder is very tiny and the compressed input file is smaller."Compiled code is 8–20 KiB."
zlib is heavier (about 200Ko).
It could be used to make self-extractible asm.js programs or to compress some embedded resources (like files from "--embedd", fonts, images...).
WebAssembly is a good compilation target for languages with a flat memory space and no garbage collection.
Alas.
[0] They don't have crashdumps yet, but I expect that they soon will.
Look at WebGL for example. Over the past 20 years there has been practically zero interest in making a safe, sandboxed version of OpenGL. It wasn't until browser vendors got involved that people even seriously considered it. Browsers had to implement most of the safety features themselves, in user space. The operating system level GPU interfaces will likely never be anywhere near as secure, because apparently OS vendors don't care about running untrusted code.
"Worse is better."
> The operating system level GPU interfaces will likely never be anywhere near as secure, because apparently OS vendors don't care about running untrusted code.
It's handled with emulation and virtualization. The future of safety looks like QubesOS.
We're somewhere in the middle.
It's all still HTTP requests and responses, but the web browser itself is becoming something very different from what it was a decade ago.
It looks very much as if we're going to lose all of that to vertical data silos that will ship you half-an-app that you can't use without the associated service. We'll never really know what we lost.
It's sad that we don't seem to be able to have the one without losing the other, theoretically it should be possible to do that but for some reason the trend is definitely in the direction of a permanent eradication of the 'simple' web where pages rather than programs were the norm.
Feel free to call me a digital Luddite, I just don't think this is what we had in mind when we heralded the birth of the www.