HN user
JSC is barely ever mentioned in the v8 team. They gave up wanting to be benchmark kings in the interest of having decent performance in Android markets (low-end and high).
Comments around cheating are likely aimed at OEMS who ship Chrome derived browsers and spin up the clock frequency when they detect certain benchmarks are running. These look great in online reviews.
This was stupid comment, long day. Totally looking at this the wrong way.
How does the hardware visible context get suitably updated if the confidential data in the other SIP isn't touched by execution (speculative or otherwise)? Doesn't something need to be pulling that state into the visible context?
In Singularity, the system gets to decide what happens at SIP boundaries (and the kernel ABI boundary).
HIP is the full address space change, but any mitigation steps can be introduced in the IPC hand-off between SIPs (or at the kernel ABI) compiled into the untrusted process. This code is compiler controlled. The system is in ring-0 so IPC code gets full access to available instructions (such as mitigation is possible there).
Of course doing this makes channel communication in both directions slow for untrusted processes, but that is the cost of doing business with Spectre. And if someone wrote a browser that didn't use channels for talking to the JS engine, then all bets would be off.
Mark Aiken wrote a paper on Singularity with and and without Memory Protection:
https://www.microsoft.com/en-us/research/publication/deconst...
By design, Singularity didn't support dynamic code loading so untrusted code would run in another software isolated process (SIP) and separated by a channel boundary (IPC). With Spectre, you'd need to rethink what happens with IPC to and fro the untrusted processes. The core of the system wouldn't need this though.
Singularity also looked to proof carrying code as a way of building reliable systems. Unfortunately, it'd be hard to prove there isn't a Spectre style attack lurking in a piece of code.
Preliminary VarHandle support in Android start in P. The API is hidden, but it had to start ahead of the Java 9 libraries because it's a lot of work.
All code needs to be capable of being interpreted as that's the fallback when compilation invariants are violated (and also when stepping through code with the debugger).
A large number of operations combined with different vartypes and backing store types (fields, static fields, arrays, Buffers, etc) makes for a lot of work, even though this is just the slow path.
There is no compiler support yet for VarHandles, or MethodHandles, on Android, but there are bugs on these.
Hey Joe, can't you just stop nagging users to use your browser and stop overriding the users choice of browser? No need to repackage anything, just move on.
Completely agree.
My home network is built with Mikrotik kit which is priced where it's affordable to have spares. I have yet to encounter a failure, but could drop in a new router in a couple of minutes with the saved configs.
I have SNMP monitoring feeding from telegraf into influxdb on an RPI. Dashboard rendered with Grafana on PC. Also have telegraf pinging to all 24x7 devices and collecting data from electricity meter, smartplugs, and Nests. It's been fun to do.
36000 lines of handwritten assembler in v8? Not since the transition to ignition and turbofan...
$ git clone https://github.com/v8/v8.git $ cd v8 $ find . -name '*.S'
There's still some macro assembler in the built-in's but it's emitted rather than being assembler.
I love what DeepMind is doing, but find their publication choices bizarre. Sure Nature has the occasional ML / NN paper, but it's not a top journal for AI / ML / CS and it makes getting hold of papers awkward and it doesn't seem in the spirit of most CS research.
Microsoft does not preinstall third party bloatware, that's OEMs running on thin margins. There have been Microsoft efforts to share with OEMs the effect of bloatware on boot times and incentivizing boot time reduction.
It doesn't take 10 minutes for a LaTeX or Word user to get frustrated with docs. What doesn't it do:
1. user defined style definitions
2. citations / bibliography
3. anchoring
There are plugins that can help, but at least where I work using these is often banned to avoid the risk of leaking corp info.
Why is this HN material? It's a Slack customer advisory.
The Linux Subsystem for Windows isn't a great example. Folks in MSR Cambridge had Linux running on Windows circa Y2K. The Linux Subsystem today comes from a second effort using Drawbridge.
Mikrotik wAP ac [1] positioned in center of home with a Mikrotik Hex POE [2] as the main router and DHCP server. There is TP-Link HomePlug [3,4] between router and WiFi base station.
The wAP ac has a stronger and more reliable signal than any other WiFI unit I've tried (various Linksys, Asus, and BT units).
The Mikrotik gear is rock solid, but not exactly what I'd call consumer friendly. Great if you know or want to know something about real routers. I got fed up with buggy consumer routers and decided to go with either Mikrotik or Ubiquity rather than struggle to get the right hardware and firmware combo for Tomato et al. Nothing wrong with these, but none of my existing hardware had an image on the various options.
[1] https://mikrotik.com/product/RBwAPG-5HacT2HnD, $89
[2] https://mikrotik.com/product/RB960PGS, $79
[3] http://uk.tp-link.com/products/details/cat-18_TL-PA4010KIT.h...
[4] Always, always change the HomePlug network name and password :-)
That is the nature of the beast except for retropiling. Method handles may be a hard set of features to implement on that path.
Coming in O by the looks of it: https://source.android.com/devices/tech/dalvik/dalvik-byteco...
Clickbait. No story until unveiling event.
Thanks for sharing. The documentation is well done, looking forward to checking out the code.
Are you sure no one else was involved in starting LLVM? PhD supervisor, fellow students, etc. Just saying...
Well, this is cool. Kudos to the folks that made this happen.
It was always a tragedy that the Windows Shell team insisted on creating their own "Shortcut" mechanism and not shaping the existing FS team symlinks to give a unified mechanism. It used to be a big ask to get teams to work with each other.
Could this be ye oldest piece of functionality to arrive in Windows yet? We also had ANSI sequences at the cmd prompt this year. And native ISO mounting in 2011. But non-admin symlinks go back way further. Cool.
NT coding style and some similarities with naming. Very clean looking in what I've seen so far. Nice work guys.
Could be that the recruiter left. My perception is that recruiters have greater churn in bi companies.
Windows also has the cool and little known CommonLogFileSystem if you need logging:
https://en.wikipedia.org/wiki/Common_Log_File_System
https://msdn.microsoft.com/en-us/library/windows/desktop/bb9...
Kudos to FB. It's a hard problem as you scale. I have a few friends who suggest the article matches their experiences there.
Being a 40-something engineer, you hear the same things over and again. I used to work at MSFT and my first manager there used to espouse company, team, self every day as the HBR article does. He'd regular re-evaluate his priorities based on what is the most beneficial task I can work on for the company today. Makes me wonder if it appears in management books or people just get wired that way.
It definitely a reasonable way to proceed most of the time. Firsthand, I have no doubt that most of the unpleasantness I've witnessed in tech companies is due to team or self over everything.
I had the feeling several times at MSFT that sometimes projects go all the way to completion for the sanity of the team.
Kin looks like an example of this. The Kin team were mostly from the SideKick acquisition and they worked really hard on it. Kin had the social angle and it would have been interesting if it had sold to the target audience (teenagers). WP7 picked up on the social aspects in Kin and that was probably final blow to it as a product (before it even shippet). It was ahead of it's time and pitched at completely the wrong price point.
AFAIK, VS uses the same implementation of the MSBuild engine but has some sleazy (buggy) performance optimizations. Add the property DISABLEFASTUPTODATECHECK=1 to get the same behavior.
We found this allowed us to eliminate differences we saw and found hard to track down and infuriating:
https://msdn.microsoft.com/en-us/library/vstudio/ms171468%28...
That's good news. I left MSFT last year and know some of the internal build toolsets have their own similar solution, but it's not integrated with Visual Studio.
IIRC MSBuild was the brain child of Alex Kipman, father of Kinect and HoloLens. As legend tells it he lashed up a demo version over a weekend and pitched it successfully in the corridor shortly thereafter. The rest is history.
MSBuild is essentially a clone ant, and it's not a bad tool per se. For the devdiv engineering team it allowed them to get off the horrible pre-msbuild project files.
The messiness came with solution files (since VS uses solution files and project files). Unfortunately, they left the also awful solution files around. And this added an alternate way to specify dependencies between projects. VS solution files are awful to maintain - just a bag of guids that makes resolving conflicts very hard for humans and VS is poor at automatically resolving them (very noticeable when you get >3 developers on a project).
The solution to the messiness would be to use an MSBuild project file instead of a solution file. It'd have to conform to a schema VS understands, but it's not rocket science. However, fixing this would require the VS source code and MSFT to accept a patch.
Using Visual Studio, gui or command line, uses the MSBuild engine though the VS wrapping does some internal caching that occasionally makes it wrong (ah! There's a cryptic flag that fixes this).
The open-sourcing is a sign that MSFT is in a tricky spot (BYOD, mobile, tablet, games) and desperately needs to improve relations with the outside world. Expect we'll also see MSFT using more open source in products to compete effectively though I wonder what'd happen with internal best practices that the outside world doesn't have, e.g. SAL. Will they contribute back? Let's see.
Inside MSFT there used to be minimal credit for releasing source which was a strong inhibitor in the employee review process. And a gratuitously awkward internal process for open sourcing code with no path for accepting changes/contributions. Attitudes are definitely improving.
The major benefit of this particular move will be when you're working on Windows drivers - now you can see and completely grok what a piece of code does until it transitions into the kernel proper.