Most public defenders offices are so oversubscribed and underfunded that they can't really provide good representation for the majority of their clients.
That sounds like a different argument: that the current public-defender system operates so poorly that the result violates the 6th amendment by failing to provide effective counsel. But the proper remedy there would be to issue an injunction ordering the system to be improved, not to unfreeze certain defendants' assets, since the latter would leave the 6th amendment violation uncured in the case of defendants who don't have assets in the first place.
The current case seems to be arguing something different: that freezing defendant's assets that they could use to pay for counsel is a 6th amendment violation even assuming an effective public-defender system. That requires a separate right, something like: the right to pay for the best defense you can afford. Afaict, this is at the Supreme Court because they've never ruled either way on whether the 6th amendment includes such a right; the previous cases have focused on the minimum threshold for what constitutes effective assistance of counsel.
Generally against asset forfeiture, but if they're going to do it, maybe using it only to fund public defenders for all would balance out the incentive for the government to seize the money in the first place.
Not really prescient. Cryptographic cash has been something that people have been talking about for a while, and there have even been startups trying to commercialize it. Chaum's ecash was invented in 1983, and he was in the process of trying to commercialize it when this was written (https://en.wikipedia.org/wiki/Ecash).
Bitcoin is just the first cryptocurrency that has actually managed to take off, but it's been a problem that cryptographers, and in particular cypherpunks (https://en.wikipedia.org/wiki/Cypherpunk), have been working on for a while.
Basically, what's happened is that this stuff that was kind of fringe and crazy back in the day, but people who were into it were really sure was the future, has actually made a major impact on the world.
Bitcoin without mixing is nice open ledger where everyone can follow transactions. Openness might be good or bad thing.
Bitcoin with mixing is subject to many laws against money laundering (anti-smurfing laws for example). Mixing is not new innovation that came with cryptocurrency.
Hmm? Their time is valuable. You are being asked to pay for their time.
If there's a broken traffic light in the city, do you expect some workers to come and spend their time fixing it just because it's broken and it's a good thing to do, or do you expect them to get paid to do it?
Now, one could argue that fixing bugs in open source software is a public good, like the traffic lights in a city. So maybe the government should pay for it? Well, I could perhaps buy that argument, but getting increased public funding for that sort of thing is likely to be hard, and it's hard to tell where that money is best spent.
But certain fixes, or new features, will help some people a lot more than others. If you would benefit from a particular bugfix, and someone else will need to do work for it, why not they ask you for money to fix it?
I work at a company that uses a large amount of free software.
For much of it, if we find a bug, we either fix it ourselves locally, or go through the normal process of submitting a bug report, possibly submitting our own patch, and waiting for a fix from upstream, while finding some way to work around it or the like.
For some of the software that is central to our business, we have a contract with a company that provides support and development services. If we have a bug that we need fixed right now, we get in touch with them and pay an agreed upon rate to do so.
We don't do this for everything we use, because most of it works off the shelf, or we just replace it or work around it, or the open development process works well enough. But for those things that are absolutely key to our business, and for which there's a consulting company that employs several of the core developers on the project, it's definitely worth it to pay for the support that we need.
Rust's model is similar to a cleaned-up and guaranteed safe use of modern C++ smart pointers and references.
A few of the improvements that Rust offers are compiler enforced move semantics by default, so assigning, returning, or passing a Box<T> (similar to unique_ptr<T> in C++) will move the ownership to the new location and statically check that you never try to access the old location. In C++, you have to explicitly call std::move(), and checks to make sure you don't reference the old one happen at runtime.
Rust also does safer checking of use of references. In C++, it's possible to return a reference to a stack variable which is no longer valid. In Rust, the lifetimes of references are tracked statically, so you can never have a dangling reference.
So, while the RAII pattern, use of smart pointers, and use of references, will feel fairly familiar to someone familiar with modern C++, they are actually generally more convenient and more safe in Rust.
Rust does not have classes. You define plain old data structures, and use traits to provide polymorphic behavior. Traits are somewhat like interfaces which can contain default implementations of methods. Traits can be used to constrain types. Traits can be used to provide either static (compile time) dispatch, or runtime dispatch, depending on whether the object is monomorphized at compile time or accessed through a fat pointer that includes a vtable to dispatch at runtime.
Rust provides generics which fill a similar niche to templates in C++. In some ways, they are more powerful as arguments can be constrained by traits; in some ways they are less powerful than C++ templates.
Rust doesn't provide operator overloading directly, but use of operators is equivalent to just calling a method defined on a particular trait in Rust. So, "a + b" is will work for any types that implement the Add trait (https://doc.rust-lang.org/std/ops/trait.Add.html), and is equivalent to calling a.add(b).
Indeed. When I'm doing a technical interview, and I ask a question, I want the person I'm asking to tell me if they don't know the answer. If they tell me that they don't know the answer, I'm more confident that when they are stuck on a problem in the real world, they will come and ask someone, or look it up, rather than just trying to bullshit their way through. In the real world, guessing can be considerably more dangerous than admitting that you don't know something and thus taking the effort to actually find it out.
For one, WebKit is now forked, into WebKit and Blink. Both of them are rapidly diverging. And there are still enough people using Gecko and Trident (and now EdgeHTML) that you can't just target the intersection of WebKit and Blink and still have any reasonable kind of coverage.
For another, I think you fail to understand just how dominant and stagnant the browser market had become when IE was dominant. Not only one browser, but one version of one browser, had over 90% market share, and in controlled environments like corporate networks, effectively 100%. In that kind of environment, it was completely reasonable to just target that one browser.
Today, even if you add up all of the WebKit and Blink browsers based on the most generous market share counts, you won't break 70% market share, and there are even still some statistics that have IE/Trident at over 50% market share. So unless you're targeting a very specific market, like iPhone users (where yes, WebKit's share is 100% due to Apple's monopoly), it's very hard to find any demographic in which there is such a strong dominance as IE had back in the day.
Additionally, browsers and engines are actually being released at regular intervals these days, with new features and bugfixes. Firefox/Gecko and Chrome/Blink are on rolling 6 week release cycles, meaning that there's very little lag to getting new features and fixes out. Safari/WebKit is released less often, but once every year or two. There were 5 years between the release of IE 6 and IE 7, and IE 7 didn't even pass Acid2, it would be another couple of years until IE 8 did. That extremely long period of time in which one version of one engine was so dominant led to an awful lot of sites designing themselves exactly around the bugs and quirks of that one engine.
Couple that with the fact that standards committees are actually working on features that people want, and are making real progress. XHTML stagnated the standards process for a long time, working on a backwards-incompatible specification that did a lot of architecture astronautics on representing documents, when what people needed were backwards-compatible enhancements that supported web applications so they could roll things out incrementally as support became good enough. CSS got a bit mired in CSS 2, but CSS 2.1 allowed them to slim down the specification and get out something working, while CSS 3 allowed them to work on individual features separately, and thus be able to make progress without having to wait for everything in the world to be ready. Another big reason for IE's dominance was that it had proprietary features, like filters and ActiveX and webfont support, and there were no standards that covered similar ground. Now we have HTML5, a plethora of new APIs for interacting with the browser, a substantial number of CSS enhancements, highly competitive JavaScript engines that are capable of running full 3D engines, and so on.
And finally, WebKit, Blink, and Gecko are all open source. People can be involved in helping find and fix bugs, implement new features, port them to new platforms and devices. A big problem with IE was that it was proprietary, and ran on one platform. You could build a desktop browser that ran on Windows with your own chrome around it, but that was about it. Now, you want to make some cool new device that needs web rendering support? You want to experiment with interesting new ways to present web content? You now have several high-quality, open source options to choose from, which have enough market share that most sites have done the compatibility work to make sure they are compatible.
Sorry for the wall of text; I just wanted to make sure that you understand the history, and how very different the present situation is than the one in which the IE 6 monoculture flourished. It can be a bit worrying how two engines with a common ancestor have such dominance on mobile, WebKit and Blink. It's also worrying that Apple's monopoly prevents people from installing browsers with more up-to-date engines on their phones; I think it's an abuse of their control of the platform. But even so, they don't have the kind of market dominance even on smartphones that Microsoft did on desktops back in the early 2000s, so while it's worrying, it's nowhere near as bad.
So, we'll be developing for 5 different target browser engines, 3 different operating systems, and about every viewport size imaginable for the foreseeable future.
>And there are still enough people using Gecko and Trident . . . that you can't just target the intersection of WebKit and Blink and still have any reasonable kind of coverage.
On the whole, that's an absolutely fantastic comment. But a few notes:
> So unless you're targeting a very specific market, like iPhone users (where yes, WebKit's share is 100% due to Apple's monopoly), it's very hard to find any demographic in which there is such a strong dominance as IE had back in the day.
As you hint towards later in your own post, WebKit/Blink are in many markets there on mobile/tablet: in Europe, WebkIt/Blink are over 90%. For many of my customers, they could make a quite sensible business decision to not support other browsers with the same level of testing. This still causes problems—we have Edge implementing large numbers of WebKit prefixed properties, Opera abandoning Presto in large part due to the WebKit domination of mobile (where, at the time, bug compatibility was necessary on several major sites), leaving Firefox as the last hold-out from supporting WebKit prefixes (and if they wish to make inroads on mobile, they'll have to).
> CSS got a bit mired in CSS 2, but CSS 2.1 allowed them to slim down the specification and get out something working, while CSS 3 allowed them to work on individual features separately, and thus be able to make progress without having to wait for everything in the world to be ready.
I'm relative certain CSS 2.1 is actually longer: it defines much of what's in CSS 2 in far more detail, with much less left undefined and fewer contradictions. What little that was dropped was dropped because it didn't meet the modern (post-2003 or so) requirements for specs to advance to REC at the W3C, namely the requirement for two interoperable implementations of each feature (technically, requirements to advance beyond Candidate Recommendation to Proposed Recommendation, whereupon the Members of the W3C vote (one vote per member) and the Director has a final say, thereafter being published as a Recommendation).
CSS 2.1 laid a lot of groundwork that's been vital for more recent modules: without a clear definition of many of the underlying layout primitives in CSS 2.1, it would be hard to define the new features in reasonable detail. That's not to say CSS 2.1 is perfect—there's work happening on CSS 2.2, primarily just integrating the current errata, and the test suite could certainly be better (Mozilla Research are paying me to work on that in the coming months, as Servo doesn't have the user base that would show many of the site compatibility bugs that arise as a result of their bugs, leaving them disproportionately reliant upon the test suite).
> Now, you want to make some cool new device that needs web rendering support? You want to experiment with interesting new ways to present web content? You now have several high-quality, open source options to choose from, which have enough market share that most sites have done the compatibility work to make sure they are compatible.
A lot of that depends on how "standard" your device is—if you're running Android, it's "relatively" straight forward. (I think Opera's recent rewrite of their browser, basing it on top of the Chromium Content API, shows that even implementing the UI is hardly a small effort.) If you're running everything statically linked, using DirectFB to write to screen (this is how many embedded browsers work), it is substantially more work, especially if you are concerned with minimising binary size. I think it's easy to underestimate how much work is involved in porting the open-source browsers to new platforms, yet alone keeping them up to date and providing security fixes (which given the short support period of each release, depends upon the former).
I was mostly responding on the basis of desktop browsers, since most of the rest of this thread has been about desktop browsers. You're right, on mobile the WebKit/Blink duopoly, with the shared code base that does mean that they are closer on feature and bug parity, is pretty problematic, but even there I'd say we're in better shape than the early 2000s IE monopoly.
> Mozilla Research are paying me to work on that in the coming months, as Servo doesn't have the user base that would show many of the site compatibility bugs that arise as a result of their bugs, leaving them disproportionately reliant upon the test suite
Nice, that sounds like it'll be quite useful. I am eagerly anticipating being able to actually use a browser based on Servo day-to-day. There's quite some ways to go, but it's great how much progress its made so far.
Already I run into issues occasionally with mobile sites not working in Firefox for Mobile. Usually I just switch to the full version of sites and they work better, but I don't think Firefox is being tested.