What every systems programmer should know about lockless concurrency [pdf] - <AUTHOR> https://assets.bitbashing.io/papers/lockless.pdf <comment><USER2> It seems like weak memory models get short shrift, but if you're going to program without locks it's semi-important to understand what information one gets when examining a read-write pair.

It's true that (as implied by the article) you can probably get by with just studying/programming with the C/C++ [1][2] "atomic" memory access types and letting the compiler enforce those semantics, though the reasoning behind a lot of these memory orderings is lost without understanding the motivation/arch. models behind them.

If you're interested in the C/C++ memory models there's active research into specifying them without bad behavior (thin-air reads [3]). Recent results include a semantics that makes value promises and requires a justifying execution [4] which is not totally dissimilar from those required by the official java memory model [5].

1\. [http://en.cppreference.com/w/cpp/atomic/atomic](http://en.cppreference.com/w/cpp/atomic/atomic)

2\. [http://en.cppreference.com/w/c/atomic](http://en.cppreference.com/w/c/atomic)

3\. [http://www.cl.cam.ac.uk/~pes20/cpp/notes42.html](http://www.cl.cam.ac.uk/~pes20/cpp/notes42.html)

4\. [https://people.mpi- sws.org/~dreyer/papers/promising/paper.pd...](https://people.mpi- sws.org/~dreyer/papers/promising/paper.pdf)

5\. [http://rsim.cs.uiuc.edu/Pubs/popl05.pdf](http://rsim.cs.uiuc.edu/Pubs/popl05.pdf)

<comment><USER3> I wonder how the memory model in [https://people.mpi- sws.org/~dreyer/papers/promising/paper.pd...](https://people.mpi- sws.org/~dreyer/papers/promising/paper.pdf) compares to the WMM and WMM-S memory models given in [https://arxiv.org/pdf/1707.05923.pdf](https://arxiv.org/pdf/1707.05923.pdf) ; and if there are other research memory models out there that should also be considered?

<comment><USER2> These papers take forever to read (take it from me, I am doing research in this area, in particular proofs of correctness for lock free programs). I recommend focusing on the C/C++ ones if only for the practical value.

As for comparison, the C/C++ memory model is more general and is operational. It is also formalized in coq and has some good theorems (data race free sequential consistency being the most obvious).

The RISC memory model is axiomatic and follows the standard axiomatic approach adopted for many other memory models like Java and the current C/C++ standard. That's not a dig, they just don't care as much about rigor.

Axiomatic models consider the every possible execution and then weed out bad ones, where as the operational semantics defines the set of all possible executions using a transition relation. If you're into math you might see these vaguely as extensional and intensional respectively.

<comment><USER3> thanks! I think the RISC/WMM folks provide an operational model too, using their own "I2E" formalism. The end of the paper seems to have a proof of equivalence between their axiomatic and operational models.

</comment></comment></comment></comment><comment><USER4> Lockless concurrency was always an "interesting" subject to me, but I never thought it was practical for me to use them. Mostly because multithreaded programming generally has easier-to-use and higher-level constructs (ie: Reader-Writer Queues already written) that can be used.

However, I've recently grown to respect Lockless Programming as I have begun to experiment with GPU programming. OpenCL doesn't give you Mutexes, and indeed, you really shouldn't "lock" an instruction pointer in a GPU ever. (On AMD systems, a singular instruction pointer runs 64 different "threads". So if one of these "threads" lock up, ALL 64 of them lock. This "Single Instruction, Multiple Data" is the key to why GPUs have so many "cores")

As such, the only practical way to write decently high-performance code with concurrency on a GPU is through Atomics (ie: Compare and Swap). Which of course, requires an understanding of memory barriers as well.

<comment><USER5> > Single Instruction, Multiple Data

*multiple threads (preferably both, in the case of GPUs, but what you described is SIMT)

<comment><USER4> I know its what NVidia calls SIMT, but its what AMD calls SIMD. ¯\\_(ツ)_/¯

NVidia is somewhat correct to call their "SIMT" concept something new, because Intel's original SIMD implementations (MMX and SSE) couldn't do the thread- divergence thing very easily (AVX 512 adds a few more features to make thread- divergence easier to handle at the CPU level). But as far as I can tell, AMD GPUs can do thread-divergence, "constant broadcasts", and all that jazz too, but AMD still calls it SIMD.

</comment></comment></comment><comment><USER6> Keep in mind lockless algorithms are not necessarily more scalable than lock- based algorithms, usually have higher constant overheads, and are significantly easier to get wrong.

However, this post is, in part, about how to implement locks.

<comment><USER7> > However, this post is, in part, about how to implement locks.

I haven't read the article in-depth but yeah, it seems like it maybe would have been better titled "What every C++ systems programmer should know about std::atomic". Which is still cool but from the title I was expecting some fancy voodoo algorithms for threadsafe non-locking FIFO queues or something.

<comment><USER8> I think it's meant to be pretty fundamental. It's not supposed to include "voodoo algorithms" because it literally says "what every systems programmer should know...". The voodoo algorithm is a voodoo algorithm _because_ not everyone needs to know it. In contrast, a mutex and all of that stuff is a consequence of how memory sequencing on a CPU works. If you understand those concepts, the rest is a hop, skip, and a jump away.

<comment><USER7> I guess my beef was mostly in response to the word "lockless", which I'd hoped meant "not using any wait-for-other-thread type semantics" but in this context seems to mean "implementing locking without using OS-provided locking primitives, although standard library is fine."

I was hoping that there was some cool new trick I'd missed or fundamentally different way to do concurrency than locking. I get disappointed easily in cases like this. :/

</comment></comment></comment></comment><comment><USER9> I have always found that the biggest hurdle in understanding concurrency amongst my peers is learning how memory barriers work.

<comment><USER10> One reason for this is that for the longest time they weren't really available in a cross platform way. I'd learn about e.g. mutexes in a computer architecture class, and then I could immediately go use them with boost or pthread or whatever.

I'd also learn about atomic operations, atomic cas, and memory barriers, but short of some very specific game libraries with weird macros for this, I couldn't find them anywhere.

It seemed like we were expected to sprinkle volatile everywhere, remember rules about unaligned access, and write our own platform specific macros for memory barriers. If you're primarily testing your code on an x86 laptop, it's very difficult to be confident that you're doing it correctly.

<comment><USER11> > I'd also learn about atomic operations, atomic cas, and memory barriers, but > short of some very specific game libraries with weird macros for this, I > couldn't find them anywhere.

How come? These days atomic ops are included in C and C++ standard library. And there are atomic operations for every important compiler out there and if you need portability across compilers (without relying on new C/C++ standards), there are portability libraries (e.g. boost).

These have existed for a long time

E.g. here are GCC's atomics: [https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic- Builtins...](https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic- Builtins.html)

> It seemed like we were expected to sprinkle volatile everywhere, remember > rules about unaligned access, and write our own platform specific macros for > memory barriers.

Unless you're using Java, "volatile" is not useful for concurrent programming. When you see volatile keyword in C code, it's almost always wrong or there for a legacy reason.

Sounds like your computer architecture classes were not up to date or very well taught.

<comment><USER10> > Sounds like your computer architecture classes were not up to date or very > well taught.

Or maybe I went to school before C++11 was around.

¯\\_(ツ)_/¯

<comment><USER11> There are many atomics libs and compilers that support atomics that predate C++11.

If you went to school in the multi-core era or slightly before that it shouldn't have been a problem.

There isn't much need for atomics on single core, single CPU machines so if you went before that, it's understandable.

</comment></comment></comment></comment></comment><comment><USER12> The thread example given in article is only limited to a single writer and multiple readers. Things get interesting when you want to have lock free concurrency with multiple readers and writers. One of the famous techniques is using software transactional memory ([https://en.m.wikipedia.org/wiki/Software_transactional_memor...](https://en.m.wikipedia.org/wiki/Software_transactional_memory)). But it hasn't really caught up in the industry and it still exists within academia.

The existing lock free concurrency solutions are not mature enough to replace locks. I like this analogy of what garbage collection is to memory is STM is to memory([https://homes.cs.washington.edu/~djg/papers/analogy_oopsla07...](https://homes.cs.washington.edu/~djg/papers/analogy_oopsla07.pdf)).

<comment><USER13> Intel has TSX [https://software.intel.com/en- us/node/524022](https://software.intel.com/en-us/node/524022)

I have never used it though and I am not sure who does.

<comment><USER14> I wish this were more useful. The real sticking point for me is that you can run out of transaction contexts - which means you have to have a full software implementation as backup.

the only case I can think of where I would actually use the thing is if I already had an STM runtime and I wanted to cut down some of the constant time overheads.

the other problematic aspect s that transaction scheduler policy is pretty important for contended performance and as part of the broader system design. in this case you have to live with whatever intel gives you

</comment></comment></comment><comment><USER15> I implemented a lockless IPC, DIPC - Interprocess Communication and Distributed IPC library in 2000-2002 time frame.

The library is used in vxWorks, QNX, Linux (both kernel and user space.) and tested heavily on Xeon SMP 1-2GHz CPU at that time.

For memory management, it was implemented in C++ and the message (Memory) Alloc/Free calls were all lockless. One can allocated a memory from kernel and send it as msg to user space and use it there without copy. The limitation is that the max allows messages are statically pre-allocated for the system. The library manages the pre-allocated pools of various sizes with lockless APIs. When the pools runs out, the API returns error.

The only primitive the library depended on was Atomic_Inc/Dec - absolutely no mutex, spin locks in the non-blocking API code path, etc.

The library was designed to support HA (High available ) TCP/IP stack and routing protocols. The APIs was not the complex. The most complicate part was the regress testing code and the diagnostic code. The API was used by team of 100+ developers. I need help them to debug complex IPC/DIPC issues - and prove to them when the error return, it was not the library/API issue.

There was a trace mechanism that track all the messages went thru the system(s). The trace system was also completely non-blocking and lockless, worked both in kernel and user space. All context switches in Linux Kernel was tracked - very similar to FTRACE in kernel today. I hacked the kernel/bios to preserve the DRAM content part of the trace system during warmboot. This way, I can recovered all the messages, last context switched info even for kernel hang, crash issue for postmortem. The trace system used rdtsc for time stamping had 0.5 nano-seconds resolution on 2Ghz Xeon CPU.

The API/Library worked fine. The overall system complexities was a big issue. We can demo TCP/IP, BGP and various routing protocols that did HA Switch over and In Service OS upgrade. But only as demo - and after switch over the state syncing took a long time and reliability of HA TCP/IP and routing protocol was an big issue.

Base on the lesson learned from that project - I went on and coded a different Application level HA system. That system based everything on top of standard Linux API/utilities. That works much better and the HA port of the SW took only 1 dev (me) 3 weeks to code. It supported in service SW (include Linux kernel) upgrade, HW/SW fault detected and automatically switch over. It was deployed in Comcast. Fault detection took < 50 ms and switch over is almost instance. Full state sync was done with wget over management Ethernet interface and always took < 1 second. All incremental states update were done over UDP and took 1 pkt.

The funny Biz/$ outcomes from these two projects:

The first one: startup sold only one HA router for $200k and burned 100M+ of VC $ but sold to Nokia for $400+Mil. I was able to paid off my mortgage with the options from that company - Not FU money but ok outcome.

The 2nd one: The startup sold $40M of products for $60K from that project to Comcast and various Cable companies at 60% margin. That product (with 19+ FPGA) was created/code/developed with ~8 HW/FW/SW engineers (including the 2 founders). The VC got "a seasoned CEO" \- managed to raise a few more rounds, kick out the founders (MIT PhD), hired 160+ people and ran the company to the ground.

</comment><comment><USER16> imho, memory-barriers.txt, in linux kernel documentation should be a required grokking before getting into lockless stuff.

<comment><USER17> Link: [https://www.kernel.org/doc/Documentation/memory- barriers.txt](https://www.kernel.org/doc/Documentation/memory-barriers.txt)

<comment><USER18> I wish I could write that well :(. This is better than most write ups with fancy graphics.

</comment></comment></comment><comment><USER19> Another one (posted by me) on "Fear and Loathing in Lock Free Programming":

[https://news.ycombinator.com/item?id=15530032](https://news.ycombinator.com/item?id=15530032)

</comment><comment><USER20> This is incredibly well thought out and written. I felt like a friend was telling me about something that we would only understand. Matt Kline, bravo.

</comment><comment><USER21> How well does Rust support these concepts?

<comment><USER22> As far as I know Rust doesn't have a memory model fully defined yet, but their type system already helps a lot.

[https://github.com/nikomatsakis/rust-memory- model](https://github.com/nikomatsakis/rust-memory-model)

A bit old, [https://blog.rust-lang.org/2015/04/10/Fearless- Concurrency.h...](https://blog.rust-lang.org/2015/04/10/Fearless- Concurrency.html)

<comment><USER23> We don't, but there's been a ton of work; [http://plv.mpi- sws.org/rustbelt/](http://plv.mpi-sws.org/rustbelt/)

For this kind of thing we mostly say "we defer to the C++ memory model" at the moment.</comment></comment></comment>


Django React Redux JWT Base Project - <AUTHOR> https://github.com/Seedstars/django-react-redux-jwt-base <comment><USER2> Note: JWT is JSON Web Token in this case, not Java Web Toolkit. This was very confusing to me as JWT is only mentioned in the title but not anywhere else in the README.

<comment><USER3> right! you can't just put JWT in there. I saw that and was like...maybe we went too far? hehe

<comment><AUTHOR> Hey, I'm the developer. I've corrected the readme. Thanks!

</comment></comment></comment><comment><USER4> Not sure why the `accounts` app is included [0]. As seen from the comments [1] in the `models.py` it looks like it's from an existing project, don't think this should be in a boilerplate project.

Nevertheless, nice boilerplate project :).

[0] [https://github.com/Seedstars/django-react-redux-jwt- base/tre...](https://github.com/Seedstars/django-react-redux-jwt- base/tree/master/src/accounts)

[1] [https://github.com/Seedstars/django-react-redux-jwt- base/blo...](https://github.com/Seedstars/django-react-redux-jwt- base/blob/master/src/accounts/models.py#L44)

<comment><AUTHOR> You're right. I copy pasted some code from some projects to build this generic one. A colleague will fix it in a few minutes :)

<comment><USER5> Including the 'accounts' app is actually pretty useful. Then even a newcomer to react and redux can see how the front and back end are hooked up.

I'd encourage anyone to look at these files:

Auth action (which depends on the accounts app and DRF): [https://github.com/Seedstars/django-react-redux-jwt- base/blo...](https://github.com/Seedstars/django-react-redux-jwt- base/blob/master/src/static/actions/auth.js)

Auth Reducer (which changes redux state based on the outcome of login/logout actions): [https://github.com/Seedstars/django-react-redux-jwt- base/blo...](https://github.com/Seedstars/django-react-redux-jwt- base/blob/master/src/static/reducers/auth.js)

</comment></comment></comment><comment><USER6> Very niche, but if you need it this could definitely save you a few hours. I wish I had this last weekend for a hackathon where I used a stack very similar to this. I spent longer than I should have to get webpack up and running with Django.

<comment><USER7> Silly question, but can't you run Django to serve your backend API, and Webpack to serve your static assets including javascript, then use an http proxy like Nginx to serve them under the same url?

<comment><USER8> well for development that's a good idea. For production you don't want to have webpack serving anything, you want it compiled, right?

<comment><USER4> That's what I do. Webpack compiles to the static/ dir and Django serves the static files in that dir. I don't know how/why you would do it otherwise.

<comment><USER9> For fast development iterations, running webpack's own web server is used for development.

Where django would instead load a custom JS endpoint in development, and use the compiled file for production.

Webpack static compile each time is just way to slow— I've seen it take 60+seconds to compile.

</comment></comment></comment></comment></comment><comment><USER10> This sounds horrifying, less is more.

<comment><USER11> Make things as simple as possible, but no simpler

For real world projects you end up needing a fair bit of stuff. I'm using a pretty similar stack and once you are up and running the majority of it falls into the background and your day to day work generally involves working only with an easy to use top layer.

</comment></comment><comment><USER12> Great work, I've been enjoying using this exact stack recently - this has definitely taught me a few things.

The main thing I'm still trying to get my head round with React/Redux/Router is where in the lifecycle to do data fetching - I noticed you're doing it in componentWillMount, when the React docs suggest componentDidMount, and I've seen others do it in various other ways with no clear indication what the 'best practice' approach is.

<comment><USER13> I understand your thoughts and normally we follow the React docs suggestions for generic components. We place data fetching code in componentWillMount in those cases we want to win some time, but if it's not the case I would recommend to place it in componentDidMount as React docs suggests.

</comment></comment><comment><USER14> What would be the best way to include some form of web sockets server/realtime pub-sub into this á la Socket.io? What's the best way to do this in Django? I feel this is an important component of any new modern web project, but it seems to be ignored here.

<comment><USER15> Take a look at [https://github.com/andrewgodwin/channels](https://github.com/andrewgodwin/channels)

</comment></comment><comment><USER16> Does this render all the React content server-side first? I wasn't able to figure out from an initial glance through the files.

<comment><USER17> No. I was looking for that too.

Some prior work on that front is: [https://github.com/markfinger/python- webpack](https://github.com/markfinger/python-webpack) \--- requires a node.js server to run in tandem. Tried it a couple of months ago, and worked, but not sure how it will handle lots of load...

<comment><AUTHOR> This was exactly our analysis. Since most of our apps don't need to be isomorphic/universal we didn't pursue this avenue.

</comment></comment></comment><comment><USER18> You could put all of this into Vagrant or Otto with a bash file to set up the dependencies to get it going.

</comment><comment><USER19> Ugh! Blah. Spit.

<comment><USER20> Which particular religious faction involved in this are you railing against?</comment></comment>


Key emails from original Android team could help Oracle's case - <AUTHOR> http://java.dzone.com/news/key-emails-could-be-evidence

<comment><USER2> The update at the bottom is most telling: Google decided to go for a third option they hadn't enumerated in the original emails: not using Sun's JVM or bytecode at all and instead writing their own.

Or you could even consider that to be a part of their #2 option; the "making enemies along the way" likely doesn't mean willful patent infringement, just that Sun would get pissed off that Google decided to circumvent their patents by reimplementing the VM.

On a side note, I'm kinda sad that G investigated a bunch of alternatives for Java and decided that they all sucked. I mean, really... Java is the best we can do? Ugh.

</comment><comment><USER3> As someone who only casually follows the case, these emails don't seem all that damaging to me.

Of course they had to at least consider licensing Java from Sun at some point. It would be weird if that was never mentioned. And of course they anticipated to ruffle some feathers with Dalvik.

<comment><USER4> There are not damaging at all, not even a whimper..remember is was slightly before those emails that Google and Sun were in talks for Sun to become a partner in completing android.

</comment></comment><comment><USER5> _Could_ , but likely won't.

One of the emails is the 'we might make enemies' quote I've seen bandied about on HN. It's not necessary to infringe patents to make enemies.

The other quote is talking about the needing a license to use Java, but that could be talking about using Sun's JVM, and may not imply that they knew that they needed to license patents, or that Dalvik would infringe those patents.

</comment><comment><USER6> Curious side note to this:

"Sorry, the blog at fosspatents.blogspot.com has been removed. This address is not available for new blogs."

</comment><comment><USER7> First thing I did when I clicked here was type ctrl-f florian.

Funny how that worked out.</comment>


Ugarit: content-addressable storage and backup written in Chicken scheme - <AUTHOR> https://www.kitten-technologies.co.uk/project/ugarit/doc/trunk/docs/intro.wiki <comment><USER3> Very nice. Content addressable storage has a number of wonderful properties. At Blekko we would hash 'keys' (like a URI) which would identify a 'bucket' where that URI was stored. This spread crawling the web evenly across multiple servers.

At Netapp I worked for a bit on a content addressable version of a filer where each 4K block was hashed and the hash became the block address. Unlike Ugarit the block hashes were in an SSD based metadata server rather than being hashed into directories. The feature that fell out of this was you got content deduplication for 'free' since any block that hashed to a particular code you already had stored you didn't need to store again. (and this exploited the fixed length defense against hash collisions).

<comment><USER4> The fact that the majority of infrastructure in tech is oblivious to something as obvious and beneficial as content-addressable storage is one of the most depressing things about the industry to me.

</comment></comment><comment><USER5> Sounds very close to bup/git and borg. In many ways, git is a content addressable storage with a couple of metadata, remote synchronization and merging features mixed in. bup uses git's internals to great effect for a backup system, and borg drops git compatiblity and elegant multi-client support, but goes farther by providing other backup functionality such as efficient pruning and built in encryption.

</comment><comment><USER6> Problem with this is, that the last development seems to have happened in 2015 and the issue tracker is pretty full with stuff going back to 2012.

<comment><USER7> I aint'n't dead :-D

Largely, Ugarit is ticking along nicely in my production setup, doing backups of my servers; when I get time I work on (a) performance, which is still weak in some cases and (b) archive mode, which is a fun spare-time project rather than something urgent I use. But the core case of doing backups Just Works(tm).

<comment><USER6> Ok, good to hear. I am seeking for a backup solution for my heterogenuos home- network, and thus evaluating the possibilities.

</comment></comment></comment><comment><USER8> If the author or a contributor is able to share, I'm curious how thia compares to camlistore.

</comment><comment><USER9> How do you handle hash collisions?

<comment><USER4> Use a big enough hash length that this is less likely than cosmic rays flipping your bits or something.

</comment></comment><comment><USER10> I wonder how performant, mature, and reliable this is.

<comment><USER7> Performance: A bit meh at bulk bytes-per-second snapshotting, particularly when the vault is accessed over ssh, as it's latency sensitive (send block, wait for response, get next block, send, wait for response, repeat - <USER2> than streaming the blocks). However, the mtime cache means that it's really good at spotting the files that have changed, so it scans my couple of terabytes fairly rapidly and uploads the tens of megabytes that have changed each day.

Mature: Well, it's been running nightly for years for me, and has saved the day on a few occasions when I've had to restore stuff from the vault.

Reliable: The only data I've lost was when a vault disk actually died, and I hadn't replicated it because, well, I was happier losing some history sometimes rather than buying more disk for that use case. However, when I get archive mode in production, I'm going to build a better vault replication solution than rsync!</comment></comment>


Election Officials Reject Hand Counts After Electronic Scanners Make Big Mistake - <AUTHOR> http://www.alternet.org/new-video-watch-wisconsin-election-officials-reject-hand-counts-after-electronic-scanners-make-big <comment><USER2> American election system is a joke from start to finish.</comment>


Smoke point of cooking oils - <AUTHOR> https://en.wikipedia.org/wiki/Template:Smoke_point_of_cooking_oils <comment><USER2> It really matters HOW an oil is produced.

"Good" olive oil enjoys a really healthy process, as opposed to most "new" oils available commercially only in recent years.

However, there is a lot of "fake" or altered olive oil in circulation. Be well aware of this. [0] [1]

[0]: [https://www.forbes.com/sites/ceciliarodriguez/2016/02/10/the...](https://www.forbes.com/sites/ceciliarodriguez/2016/02/10/the- olive-oil-scam-if-80-is-fake-why-do-you-keep-buying-it/#1e627804639d)

[1]: [https://www.amazon.com/Extra-Virginity-Sublime-Scandalous- Wo...](https://www.amazon.com/Extra-Virginity-Sublime-Scandalous- World/dp/0393343618)

</comment><comment><USER3> I've never understood what I'm supposed to do with this information. My stove gives me heat information in low to very high or in numbers from 1 to 6. How does that translate into a temperature? I have no idea how hot my frying pan ever is in Celsius.

Edit: no idea what I'm being downvoted for, okay

<comment><USER4> In addition to just using a thermometer, many recipes tell you to heat the oil until it starts smoking. So now you know roughly what temperature that is based on the oil used.

If you need to find a substitute for a cooking oil, smoke point is probably the most important factor with which you compare oils, followed by neutrality of flavor.

</comment></comment><comment><USER5> I recently switched to using safflower oil for most things. It's completely changed how my steaks come out on the grill. Previously I've used peanut, corn, olive, avocado, canola, and vegetable. And so far safflower has given me the cleanest flavor. Also works great for simple stuff like scrambled eggs. I still use olive oil a lot for the flavor it gives for things like roasting vegetables in the oven. But safflower is my knew favorite

<comment><USER6> You didn't mention Coconut oil the best tasting oil.

<comment><USER7> OMG can't stand it.

<comment><USER8> Go refined then, has basically no flavour but a healthy oil with a high smoke point.

<comment><USER9> gotta be careful if you use refined coconut oil, some of them contain partially-hydrogenated fats which are rather unhealthy.

<comment><USER8> Good call, wasn't aware of that so I'll keep an eye out.

</comment></comment></comment></comment></comment></comment><comment><USER10> I once left a cast iron skillet on the stove about 1/2 full of canola oil for about 10 minutes on high heat. I was heating it up to deep fry something (don't do this) and got distracted. I started picking up the pan to move it to another burner when the oil burst into flame.

Everything turned out okay in the end but the fire department got called out (building smoke detector went off) and I had to repaint the kitchen.

All that to say smoke point is serious business

<comment><USER11> This is why you always want to know where your salt is, and your fire extinguisher too.

I had a room mate do the same thing once. The flame must have been at least 4-5ft tall, hitting the ceiling. She grabbed a box of salt and started pouring it on the oil. This killed the fire rather quickly, before even a smoke detector went off or it created any damage.

<comment><USER12> Would salt work better than baking soda?

<comment><USER13> Whatever cools off the oil the quickest will work the best.

<comment><USER14> And isn't water.

<comment><USER15> I once tried to put away an oil fire with water, and I can attest it is not a good idea. The flames were impressive, though.

</comment></comment></comment></comment></comment></comment><comment><USER16> I have a teflon pan with which I can use butter in to make omelettes and I have a stainless pan that I generally use lard (bacon drippings) because the omelette will stick if I use butter. I am obviously vegawarian at best.

What do vegetarians use for omelette in a steel pan?

<comment><USER17> Vegetarians use butter, but if you're smart you use a well seasoned high carbon steel pan, or cast iron.

The best seasoning for a pan is done with flaxseed oil, as far as I understand, as it has a low smoke point so the oil will polymerize and turn into a glassy surface.

<comment><USER18> The flaxseed thing comes from a 2010 blog article [1], which purports to be a scientific approach to seasoning pans. As people have found out, it's unfortunately not a good idea.

Aside from the fact that flaxseed is ridiculously expensive compared to the traditional alternatives, it creates a brittle surface and flakes off after a while. It also requires a ridiculous number of coatings to get to the right level of smoothness. It's just not worth it compared to something cheap like canola or soy.

A lot of people have looked into it. Here [2] is a good Reddit post from /r/castiron.

But among all of the technical discussions about seasoning it's easy to forget that a pan generally only needs to be seasoned once, and most pans you can buy are well pre-seasoned, and using the pan for cooking is also a form of seasoning.

[1] [http://sherylcanter.com/wordpress/2010/01/a-science-based- te...](http://sherylcanter.com/wordpress/2010/01/a-science-based-technique- for-seasoning-cast-iron/)

[2] [https://www.reddit.com/r/castiron/comments/5owtnm/why_i_dont...](https://www.reddit.com/r/castiron/comments/5owtnm/why_i_dont_recommend_flax_seed_oil/)

<comment><USER19> In my experience, you'll eventually cook something in the cast iron that sticks really hard, and the only easy ways to get the burnt-on gunk out end up stripping the seasoning, so re-seasoning ends up being a roughly semiannual process in my house. Would love to know how to avoid this.

<comment><USER20> I usually heat up the pan directly after cooking and wash it under the hot water. Just heat enough so it makes a bit of steam when it hits the water, scrub with a wooden spatula.

Or while cooking, add water if it fits whatever you cook. Make a sauce out of what is left after the sunday steak is out of the pan.

</comment></comment></comment></comment></comment><comment><USER21> For people wondering _what_ the smoke point is here is the full wiki page [https://en.m.wikipedia.org/wiki/Smoke_point](https://en.m.wikipedia.org/wiki/Smoke_point)

<comment><USER22> The article fails to mention why the smoke point matters. Is it something you want to avoid?

<comment><USER23> It's the point at which the oil burns. Thus, if you need to cook higher than that temperature, you're gonna end up with burnt oil.

</comment></comment></comment><comment><USER24> I've always heard that canola has a much higher smoke point than olive, but the page suggests they're near the same (depending on the olive oil).

Thoughts?

<comment><USER25> Why bother w/ olive oil if it isn't extra virgin?

<comment><USER26> Olive oil is healthy, good to cook with, and not too strongly flavoured. Depending on where you are, it's also generally fairly cheap. As a general purpose cooking oil, it's a solid choice, and EVOO is _not_ a particularly good replacement.

It's like asking why you'd want a screwdriver when you already have a really nice hammer; they're different tools for different purposes.

<comment><USER27> Here, in Spain, it's cheap. We nearly only use olive oil, and sometimes sunflower oil. It's really hard to find any other kind of oil.

</comment></comment></comment></comment><comment><USER28> My takeaway is, wow, avocado oil is hardy stuff!

<comment><USER29> It's become our main cooking oil. In addition to its high smoke point, it is a more neutral flavor when compared with olive oil.

<comment><USER30> I couldn't find Costco's usual non-stick spray 2 pack, so I got their Avocado spray instead. It has virtually no non-stick qualities from what I could tell.

<comment><USER31> Cooking spray is just oil in a spray can, usually Canola.

<comment><USER32> Cooking spray is _not_ just oil in a spray can, because additives are necessary for it to work well in a spray can.

</comment></comment></comment></comment></comment><comment><USER33> Hmm they usually recommend flaxseed oil for seasoning cast iron skillets. It seems like its smoking point is very low, and recommended seasoning temp is around 400-500'F. Wouldn't something like avocado oil be better?

<comment><USER34> If you don't heat the oil above its smoke point then nothing will happen to the oil, chemically. This is not what you want when seasoning cookware. The purpose of heating the oil and cookware is to induce polymerization so that the oil becomes bonded to the surface.

As far as I know, this blog post [1] is the originator for the recommendation to use flaxseed oil specifically for seasoning cast iron. I am not a chemist, so I can't vouch for the accuracy of the information.

[1] [http://sherylcanter.com/wordpress/2010/01/a-science-based- te...](http://sherylcanter.com/wordpress/2010/01/a-science-based-technique- for-seasoning-cast-iron/)

<comment><USER35> I've seen a number of other cooks disavow flaxseed oil after that blog post's rise in popularity. They say, anecdotally, that flaxseed oil flakes off more easily than regular vegetable oil seasoning.

<comment><USER34> That may be due to using a flaxseed oil with impurities or not using high enough temperature during the seasoning process. Cook's Illustrated [1] put the flaxseed method to the test and found it superior to vegetable oil.

[1] [https://www.cooksillustrated.com/how_tos/5820-the- ultimate-w...](https://www.cooksillustrated.com/how_tos/5820-the-ultimate-way- to-season-cast-iron)

<comment><USER36> I wish they tested different oils. I didn't see flax on the wikipedia page, but another page says 225° F [1]. This page [2] mentions flax seed oil flaking off and recommends refined grapeseed oil (which looks to have a smoke point of 400° F).

Usually, I see flaxseed oil in the refrigerated section. I don't have any experience with it, but perhaps the fickleness of storing it causes flaking in practice? Either way, it sounds like there are better alternatives to those two.

[1] [https://www.theglobeandmail.com/life/health-and- fitness/heal...](https://www.theglobeandmail.com/life/health-and- fitness/health/smoke-point-matters-in-cooking-with-oil/article26569060/)

[2] [https://fieldcompany.com/pages/how-to-season-cast-iron- pan-s...](https://fieldcompany.com/pages/how-to-season-cast-iron-pan-skillet- instructions)

</comment></comment></comment></comment></comment><comment><USER37> I've found a good way to handle the smoke point is to heat butter and mix it with a cooking oil with a higher smoke point; in my experience this raises the smoke point of the butter a lot without giving up the taste.

<comment><USER38> Not true. [https://www.seriouseats.com/2014/09/does-mixing-oil-and- butt...](https://www.seriouseats.com/2014/09/does-mixing-oil-and-butter- really-alter-the-smoke-point.html)

<comment><USER39> Thank you for posting this!

The "butter plus oil has a higher smoke point" theory is like building a house that's half tungsten and half wood and claiming it can't catch fire.

<comment><USER40> Maybe if you had the wood half be encased in a tungsten shell?

</comment></comment></comment></comment><comment> lota-putty Our family* moved from Peanut & Sunflower oils to Rice-Bran, Mustard & Palm oils a decade ago.

Rice-Bran : cooking

Palm : frying

Mustard : taste toppings

* lower middle-class Indian

<comment><USER41> You should not use Palm oil since it is destroying rainforests.

</comment></comment><comment><USER42> I wish Wikipedia would allow sorting tables by column. I know Confluence has that.

<comment><USER43> It does. Are you by chance looking at the mobile version?

<comment><USER42> Yes

</comment></comment></comment><comment><USER44> tl;dr: Use avocado oil. It's fairly cheap (Costco), mostly tasteless, and good for pretty much everything.

</comment><comment><USER45> There are an awful lot of random Wikipedia articles being posted lately. Some of them are interesting and on topic, but this one? Come on.

<comment><USER46> If you do cooking at home, this is a pretty interesting topic to learn about, I think.

<comment><USER45> Fine, but... it's just a table of numbers. There's nothing interesting or thought-provoking about it.

<comment><USER47> Numbers that represent things, things which have important implications for human health.

This relates to nutrition, chemistry, industrial processing and more, so I'm not surprised to see it here. I found this article independently many times before today because these topics are interesting to me, and I always enjoy obscure and data-oriented Wikipedia articles.

</comment></comment></comment></comment><comment><USER48> Would suspect a very common mistake a lot of people make is using extra virgin olive oil to cook with at a medium or high temperature. Don't do it.

I've found ghee (clarified butter) to the best thing I've found for anything requiring medium or higher cooking temperatures.

<comment><USER49> I used to worry about that but it turns out that cooking (even flying) with extra virgin olive oil is totally fine. The problem with the low smoke point in evoo is a myth.

[https://www.aboutoliveoil.org/olive-oil-smoke-point- measured](https://www.aboutoliveoil.org/olive-oil-smoke-point-measured)

<comment><USER50> This is doesn't pass the burnt smell test. First of all, anyone's who's done even a little bit of cooking will notice that extra virgin olive oil smokes / burns very quickly.

Secondly, this article claims "the oil and the food did not exceed 180⁰ F" which is well below the point where Maillard reaction occurs. Maybe in their specific "we represent the olive oil industry" environment, it didn't exceed this temperature, but I'd take that with a grain of salt.

<comment><USER27> I always cook with virgin oil and NEVER I get it to burn. Even putting the fire to max.

</comment></comment></comment></comment><comment><USER51> "heat the food, not the oil".. A Smoke Point is not the issue, it is well before that, when heat breaks long bonds in the whole oil into shorter, less digestable and less nutritious forms... quality oils are a secret to long life ! conversely, low-quality and "broken" oils will wear and pollute the body over time.. personally, I use water during cooking for many whole foods, and add oil at later cooking stages (which takes practice, and is not a universal recommendation)..

<comment><USER52> The Mailard reaction is the scientific description of browning food. It happens with amino acids (in virtually every oil) and sugar combined with heat. Going above roughly 180C / 355F results in a different chemical reaction known as pyrolysis aka burning.</comment></comment>


Ask HN: How to Force Heroku / Salesforce to Comply with GDPR Request? - <AUTHOR> I have a suspended Heroku account which I couldn't log into. I plan to move to another platform.
I have reason to believe the account may contain personal data. The code itself is my client's property and trade secret (I run a consulting biz) which I wish to erase too. Emails sent to Heroku suspended account department / Salesforce privacy email address went unanswered. Their support hotline and chat bot redirected me to a help portal.
At this point it seems they don't honor their privacy policy at all, https://www.salesforce.com/company/privacy/ If anyone knows how best I should proceed, please enlighten me.
P/S no reason has been given as to why the account was suspended. I am only on free tier, so no unpaid bills. The code is hello-world-ish, unfinished with no external traffic, no heavy load. I suspect some kind of trigger-happy bots scanned the source code and auto-suspended the account without any review. <comment><USER2> Does the GDPR cover you? Are you in Europe?

<comment><AUTHOR> I am not in Europe but it should cover me, because the personal data (if exists) on the server belong to EU individual.</comment></comment>


This is the most dangerous time for our planet - <AUTHOR> https://www.theguardian.com/commentisfree/2016/dec/01/stephen-hawking-dangerous-time-planet-inequality?CMP=Share_iOSApp_Other <comment><USER2> The elite are not really elite. That's the problem. The real elite are the scientists, philosophers, engineers, and so on, the actually intelligent, but most of the actual elite have been made into slaves by the pseudo elite using money. The real elite are barely given enough time to think about the big picture, and confined to work on smaller problems that the results of which are used by the pseudo elite to mostly make more money and amass more power.

Who runs politics? Is it not money that runs politics, or is it intelligent people who constantly warn the idiots that they are doing wrong, and then slowly while preserving their power and money react to fix problems that they are causing. I guess to intelligent people the masses are more worrying, and probably should be. But the people running the world are not all that much higher then them. They just have money.</comment>


Ask HN: How to achieve and maintain mastery in spoken English? - <AUTHOR>

I speak English as my third language and have always strived to improve my writing by reading a lot. We recently moved back to Europe from the Bay Area and I've noticed that my pronunciation and active vocabulary has deteriorated in a mere few months.<p>What resources are out there for native (or close to native) English speakers to improve their spoken language? I listen to podcasts but have found that the language quality isn't uniformly high. <comment><USER2> I am French and live in Australia.

I find that writing is more powerful than reading in terms of learning a language (or maintaining it) because your mind needs to really switch to the other language. Reading is more passive.

If you are really serious about keeping your english, you may want to run your own podcast to keep speaking in English (and listen to podcasts).</comment>


Why I hate Google Chrome? - <AUTHOR>

It's about 2 years that I switched to Google Chrome from Firefox. All my data, histories and saved authentications are stored in all last two years on Google Chrome.
Today, when I was going to the "cookies and data sites" tab from settings menu for removing one specific record from history, suddenly I clicked wrongly on the "Remove all" button inside the box.
What you expect to Google Chrome do after clicking on that hell button? Confirming that "Are you really want to remove all your cookie/session data?", right?
But it's completely removed all of my two years (cookie and authentication) data, without asking/confirming me.
REALLY, I HATE GOOGLE CHROME NOW. <comment><USER2> > But it's completely removed all of my two years (cookie and authentication) > data, without asking/confirming me.

So at your behest Chrome deleted what is probably the most common, and commonly misunderstood, everyday security vulnerability, and now you're all mad about it?

The majority of those cookies were ways for advertisers and merchants to track you and your consumer preferences, and violate your privacy. I've heard reports that Amazon shows one set of prices to those with a long record of browsing and purchases in a given product category (a record keyed to browser cookies), and another to someone with no history in that category.

Cookies aren't your data -- cookies are the data of merchants and advertisers. They should be purged regularly.

<comment><AUTHOR> I can accept your reason partially, but just another question, should Chrome confirm me before remove them all?

<comment><USER2> > should Chrome confirm me before remove them all?

1\. I am sitting at Chrome right now, Version 25.0.1364.152.

2\. I choose "Settings".

3\. I choose "History".

4\. I choose "Clear all browsing data ...". See the ellipsis? That means it won't take any action until I allow it.

5\. Next, I see a dialog that says:

        Clear all Browsing data

        Obliterate the following items from the past hour/day/week/month/etc.:

          ☑ Clear browsing history
          ☑ Clear download history
          ☑ Empty the cache
          ☑ Delete cookies and other site and plug-in data
          ☑ Clear saved passwords
          ☑ Clear saved Autofill form data
          ☑ Clear data from hosted apps
          ☑ Deauthorize content licenses

                 [Cancel] [Clear Browsing Data]

6\. Here's a picture of the dialog: <http://i.imgur.com/Du84Y4O.png>

7\. At this point, I have the choice to [Cancel] or [Clear Browsing Data]. _Nothing happens without my permission_.

So tell me -- what Chrome version are you running, that doesn't have a very complete way to alert you to what's going on?

I invite you to go to your Chrome settings page and see if your experience differs, and also say what Chrome version you are running.

</comment></comment></comment><comment><USER3> A confirmation dialog is something one would expect in a consumer-facing app - and it isn't difficult to build.

I'd be interested to know what their design decision was not to do that.

<comment><USER2> I just checked and Chrome _does_ have an elaborate, multi-step confirmation procedure to delete the data under discussion. Here's a picture:

<http://i.imgur.com/Du84Y4O.png>

</comment></comment><comment><USER4> To be honest, you should've already removed all that useless data. I really don't get why you HATE Google Chrome now after clearing up your stuff.

I'd say: "Good guy Google Chrome".

<comment><AUTHOR> Those are not USELESS data, those are my all authentications over the Internet, Facebook account, Gmail account and...

<comment><USER2> > Those are not USELESS data, those are my all authentications over the > Internet, Facebook account, Gmail account and...

Yes, and because of those cookies, anyone sitting at your computer can log on and pretend to be you without having to know your logon names and passwords. Anyone who hacks your computer from afar and gains access to this treasure trove of sensitive information can use those cookies to steal your identity.

<comment><USER5> I can't remember the last time someone else used my computer. And if someone hacked my computer from afar, I would imagine random cookies to be the least of my problems.

<comment><USER2> > I can't remember the last time someone else used my computer.

Yes -- and if a hacker does his job, you will never remember it, because to all outward appearances, it never happened.

> And if someone hacked my computer from afar, I would imagine random cookies > to be the least of my problems.

A random cookie or authentication record containing your logon details for an online site, with which someone could pretend to be you? Don't you realize what it means when the browser asks you whether it should "remember" your logon name and password?

<comment><USER5> > A random cookie or authentication record containing your logon details for > an online site, with which someone could pretend to be you? Don't you > realize what it means when the browser asks you whether it should "remember" > your logon name and password?

It implies saving that password on the hard drive, yes. However, any interested attacker, once gaining access to my account, can just as easily install a keylogger and simply wait for me to log in to this site the next time. Or for me to enter the passphrase for my SSH keys or GPG keys, which is likely more interesting than my HN account.

He could also access my email account and send spam via my server (because, yes, I do let Claws save my password…), or could use all the other data on this hard drive (pictures, CV, instant messaging logs, emails, etc.) to impersonate me.

Really, what's so special about authentication cookies that they absolutely must be secured?

Okay, here's one difference: Assuming an exploit in Opera allowing for arbitrary code execution, the OS won't block access to wand.dat, but it will, thanks to AppArmor, block access to ~/.ssh (in fact, everything but ~/.opera and a few other select directories). Circumventing AppArmor either requires root access (theoretically possible assuming a fault in the kernel) or tricking me into running code I don't want to run outside of the AppArmor profile, e.g. by adding an exploit to a downloaded PDF file I then open in Evince.

But, uh, yes, this requires arbitrary code execution in at least one of the internet-facing applications, most of which are enclosed in their respective AppArmor profile, and then some sort of escape from said profile if one wanted to read anything not naturally relevant to the programme exploited (~/.opera/wand.dat from Pidgin, e.g.).

However, if someone is actually able to run arbitrary code in Opera, they can at least access all cookies of the current session, even if I didn't let the browser remember the password, as well as install backdoors in the browser[0] to record future logins and send them somewhere. So by not letting Opera remember passwords, I secured those passwords which I didn't use in the current session. Considering that usual sessions in Opera last about four to eight weeks for me, that gain is rather minuscule compared to the hassle of entering/remembering or copy-pasting passwords from somewhere else.

[0] Opera evaluates user-provided Javascript files in ~/.opera pretty much all the time, so it is not necessary to write to /usr/bin/opera for that.

<comment><USER2> > It implies saving that password on the hard drive, yes. However, any > interested attacker, once gaining access to my account, can just as easily > install a keylogger and simply wait for me to log in to this site the next > time.

Yes, but that is much more work, over a longer period of time, compared to browsing your cookie jar.

By the way, this entire conversation is predicated on a misconception -- Chrome does, in fact, give one plenty of warning about deleting personal information:

<http://i.imgur.com/Du84Y4O.png></comment></comment></comment></comment></comment></comment></comment>


NF: Open source hacker news link aggregator based in Berlin mit GitHub oAuth - <AUTHOR> https://nullfrequency

<comment><AUTHOR> Open source and built over the last seven days [https://github.com/nullfrequency/nullfrequency](https://github.com/nullfrequency/nullfrequency)

</comment><comment><USER2> Please get rid of the light grey text on white background. I can barely read half of what's on there.

Other than that, looks nice.</comment>


The Great Oil Swindle - <AUTHOR> https://seekingalpha.com/article/4132359-great-oil-swindle?ifp=0 <comment><AUTHOR> [https://www.investing.com/analysis/the-great-oil- swindle-200...](https://www.investing.com/analysis/the-great-oil- swindle-200273801) for the non-paging article.</comment>


Asiana Airlines Flight 214: A Pilot's Perspective - <AUTHOR> http://www.slate.com/articles/news_and_politics/transport/2013/07/asiana_airlines_crash_stop_blaming_sfo_s_runways_and_korea_s_pilots_for.single.html

<comment><USER2> This is on the front page right now.

[https://news.ycombinator.com/item?id=6012214](https://news.ycombinator.com/item?id=6012214)</comment>


Meet Apple's Favorite Blogger - Gruber of Darringfireball - <AUTHOR> http://www.businessweek.com/articles/2012-09-06/meet-apples-favorite-blogger

<comment><USER2> Does Daring Fireball really make $500k a year? I know it says that Gruber won't confirm it but that figure seems awfully high.

<comment><USER3> Just the sponsored feed brings something like $150,000-$200,000 a year. Add the Deck ads and the t-shirt sales, and you are there.</comment></comment>


Google to Android Developers: 'Do Not Develop in the Open' - <AUTHOR> http://www.readwriteweb.com/hack/2011/09/google-to-android-developers-d.php

<comment><USER2> Android is open in the same sense that the Lua programming language implementation is open. Lua is certified open-source software, and distributed with a very liberal license, but PUC-Rio is in complete control of all the development.

It's certified by the OSI, whose definition of "Open-source" is available at <http://www.opensource.org/docs/definition.php>. To summarize, open-source means (1) The software and modifications can be redistributed freely, (2) The source code is available, (3) Users are free to modify the software. Android meets these requirements.

The software is open-source. The project development is not open: See <http://www.lua.org/license.html>

> Lua is free open-source software, distributed under a very liberal license > (the well-known MIT license). It may be used for any purpose, including > commercial purposes, at absolutely no cost. Just download it and use it.

> Where does Lua come from?

> Lua is designed, implemented, and maintained by a team at PUC-Rio, the > Pontifical Catholic University of Rio de Janeiro in Brazil. Lua was born and > raised in Tecgraf, the Computer Graphics Technology Group of PUC-Rio, and is > now housed at Lablua. Both Tecgraf and Lablua are laboratories of the > Department of Computer Science of PUC-Rio.

and [http://lua-list.2524044.n2.nabble.com/Lua-open-source-or- not...](http://lua-list.2524044.n2.nabble.com/Lua-open-source-or-not- td5586188.html#a5588414)

> An "open-source project" has one meaning, an "open-source software" has > another. The project is not open source, the software (the result of the > project) is.

Few people have had a problem with this principle as applied to Lua. I'm not sure why this is confusing or newsworthy when it's applied to Android.

<comment><USER3> > Few people have had a problem with this principle as applied to Lua. I'm not > sure why this is confusing or newsworthy when it's applied to Android.

This is why people have a problem: <http://twitter.com/#!/Arubin/status/27808662429>

<comment><USER4> What's wrong with that tweet? It fits the definition of open source that your parent post described.

I think a lot of people's problem comes from Google having not yet released the Honeycomb source code. It's one thing to say you're open source, provide all your source for each release, but develop in private. It's another thing to say you're open source, develop in private, and _not release the source code to your released software._

<comment><USER5> Except the fact that it tries to define "open" and not "open source". For me, Mozilla Firefox or Ubuntu are open. All development, the planning etc. can be viewed at at all time. All parts of the full stack are open and free. You can participate if you want.

Android can be forked and inspected, which are the fine things about open source, but it cannot be followed like you can with "open" software.

<comment><USER6> Everybody has a different definition of open.

<comment><USER5> Thank you for a lesson in an obvious topic, and incidentally thats why I wrote "For me", and not "For everyone".

But lets put it in another way: its hard to argue that all aspects of Android are 'open' while its easy to argue that some of them are definitely 'closed'. Whether that sums up to a "open" or "closed" verdict is not up to me. For me it sums up as being somewhere in the grey area, more to the "closed" side after the Honeycomb incident.

</comment></comment></comment></comment></comment></comment><comment><USER7> I'm sorry, but I'm with Jason Kincaid on this one.

[http://techcrunch.com/2011/09/07/the-bombshell-that-wasnt- fo...](http://techcrunch.com/2011/09/07/the-bombshell-that-wasnt-foss-patents- android-scoop-misses-the-mark/)

There wasn't anything new in those documents. We already knew that Google only put out final releases and we already knew about lead phones. It was all public knowledge.

That doesn't mean that it has no bearing on the case, but it's not revelatory.

<comment><AUTHOR> I normally wouldn't touch anything that has Florian Mueller's name attached with a ten foot pole, and I certainly wouldn't bet any money on there being a connection between this theory and the settlement talks. On the other hand, that's not to say that I think it's impossible, but Mueller has been too far off the mark too many times.

The real news here (as far as I am concerned) is that the judge has suggested settlement talks, which to me, in my legal ignorance, sounds like he thinks the case has some merit?

<comment><USER8> Courts typically take a very dim view of parties that refuse to partake in mitigation or attempt to settle: they rightly view it as wasting the court's time, especially if the proposed settlement was near or exceeded what was eventually decided. This is usually true regardless of the relative merits of the case.

</comment></comment></comment><comment><USER9> Community Open Source is a subset of the whole Open Source thing, but not having an open development process doesn't make your code closed source. Google releases Android source code under the Apache 2.0 license, which is definitely open source, so: Where's the matter?

This just looks like smoke in the eyes from Oracle lawyers.

<comment><USER5> This is true. But open sourcing your point releases (or not) doesn't make your software "open" as Google wants to advertise. Most of the Android eco-system is actually as closed as with every other platform, most glaringly the whole development process. This piece just shows that this is exactly what Google wants (which is perfectly fine for me, except the false advertising).

<comment><USER10> Amazon is about to fork Android, taking the result from thousands of man- months worth of effort funded by Google and making it their own. I think that's the definition of an open source project, anyone can fork it.

<comment><USER11> But can I fork it?

Nope, because I do not have access to the latest code, therefore I do not consider it open or open source.

<comment><USER12> Why can't you fork it without the very latest code? You have access to the code that ships, which is the requirement of viral open-source licenses.

You don't have access to the "very latest code" for the Linux kernel either, that resides (in many separate pieces) on various developer's workstations. By the time it actually gets committed, some other developer has made modifications to their working copy (arguably making it "the latest version") and not pushed that up yet.

<comment><USER13> >You have access to the code that ships, which is the requirement of viral open-source licenses.

Except we _don't_ have access to the code that ships. The code shipping on Honeycomb device is not available.

>You don't have access to the "very latest code" for the Linux kernel either

Using an 8 month old version of the Android source is not the same as not having access to kernel code that is still being written. With the linux kernel you can access code as soon as it is committed to kernal.org, with Android you only get to see it after an entire new version of the OS has been released (and sometimes not even then). It is perhaps difficult to draw a solid line here, and pedants will complain that you don't have access to code that still only exists in Linus' brain, but there seems to be a pretty clear difference to me.

<comment><USER12> > _Using an 8 month old version of the Android source is not the same as not > having access to kernel code that is still being written. With the linux > kernel you can access code as soon as it is committed to kernal.org, with > Android you only get to see it after an entire new version of the OS has > been released (and sometimes not even then). It is perhaps difficult to draw > a solid line here, and pedants will complain that you don't have access to > code that still only exists in Linus' brain, but there seems to be a pretty > clear difference to me._

You're right, there is a difference. But the difference is one of _process_ , and isn't really related to the openness of the software itself.

<comment><USER13> It very much is related to the software: Android 3.x is not open source because this ' _process_ ' has meant the code has not been released.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER14> The title is very misleading and should be changed. It sounds like Google is telling the developers of apps that they can't use open source licenses, when it's actually google as a company develops the Android OS in private, then releases the source to the public after it is developed.

</comment><comment><USER15> As an untrained reader, I find this very strange. Not open sourcing your products could be a reason to forbid a merger, because you could gain an advantage over your competitors? Really? Is it illegal to be better than your competitors?

It almost sounds as if there was a law that companies have to open source their products, which I am pretty sure does not exist (IANAL, though).

<comment><USER16> Google _does_ open source Android. The point is about when they make a public release of the source. They are only obliged to release the source when they release the code to the public, and the point is that they don't do this any earlier than they have to.

This does make the Android _development process_ less than open. It does not stop Android being open source.

The relationship to the court case is that Google's development process is very much at question in the issue of whether there is a violation of Oracle's IP.

<comment><USER15> I don't think they are obliged to do anything.

</comment></comment></comment><comment><USER10> The bigger news is the settlement talks. Is Google really going to cave and pay royalties?

</comment><comment><USER17> It's still open source if the source is published later, but I think being open source is not enough any more (was it ever?). Android needs open governance, right now it's Google's project and they control it as they see fit.

<comment><USER15> "being open source is not enough any more (was it ever?)"

Meanwhile Apple rakes in billions with closed source software. What's more, people cheer them on for it and hail them as the saviors of mankind.

<comment><USER18> > people cheer them on for it and hail them as the saviors of mankind

[citation needed]?

Nobody is specifically cheering because it's closed source. I would cheer even more if they had iOS _and_ opened it up for minor tinkering.

<comment><USER15> I just deleted my rant that I wrote as a reply to this.

Look, there have been a zillion articles raving about Apple in the last two weeks. Just google for yourself, don't ask me for citations about the most blatantly obvious things. It really annoys me.

No, they usually don't cheer the closedness (although it happens often enough), but they don't seem to mind it, either.

<comment><USER19> I've been reading your comments for some time and you seem to have serious anger problems when the subject is Apple. Also, you're very disrespectful to Apple users, bringing the topic even when it has nothing to do with the company. I seriously recommend a psychiatrist or counselour. Apple/Google are not religions, my friend!!!

</comment></comment></comment></comment></comment><comment><USER20> I'd call it Shared source software or, to be precise, Later shared source software.

</comment><comment><USER21> C'mon Google, let us develop with Go or Python, I hate Java with the passion!</comment>


Coinbase changes conversion fee calculation - <AUTHOR> https://support.coinbase.com/customer/portal/articles/2109597-buy-sell-bank-transfer-fees <comment><AUTHOR> This is what's changed on the fee support page: [https://gist.github.com/charlieegan3/dc7d3ee49d8a2b8c16d02fe...](https://gist.github.com/charlieegan3/dc7d3ee49d8a2b8c16d02fe1970e07ea/revisions?short_path=784fffb#diff-784fffb7aa2d728cf4e4cbda54fadc11) (Comparing today against the 29th of April.)

A simple example is that buying £1 of BTC used to cost me £1.02, now it costs £1.76.</comment>


Kinoni (Turn your phone into a webcam) - <AUTHOR> https://www.kinoni.com/ <comment><USER2> What's the business model if it's free?</comment>


Run Caddy on your laptop with inlets - <AUTHOR> https://github.com/inlets/inlets-pro-pkg/blob/master/docs/caddy-tutorial.md <comment><USER2> Curious if this has benefits over an ssh reverse port forward set up. It doesn't seem any simpler, but perhaps it does something better.

<comment><AUTHOR> That's an insightful question. I would say that the user-experience _is_ simpler and the automation is richer, look at inletsctl and inlets-operator for instance and the Kubernetes service discovery. Inlets OSS can also multiplex sites and is more comparable to Argo Tunnels from Cloudflare or Ngrok than ssh.

Because inletsctl/operator uses cloudinit it is slightly easier to automate than setting up authorised ssh keys and then managing those, but the end result of local traffic appearing somewhere else is the same.</comment></comment>


Ask HN: What are some Chrome extensions that you wish you had? - <AUTHOR>

I'm looking into developing some Chrome extensions. Share your paint points and I shall relieve. <comment><USER2> Two that I keep wishing for:

(1) An easy way to download YouTube videos (preferably, any site's videos, but YouTube is the obvious target). There used to be several extensions that did this, but they all seem to have been broken by some recent change Google made.

(2) An URL rewriter: something that lets me set up a list of regex-based transformations to apply to any link I click on, redirecting me to the transformed URL instead of the original one. There are all sorts of uses for this, but the one that keeps annoying me on a regular basis is sites like DeviantArt that make you go through an "are you sure you want to leave our wonderful site?" page on every outgoing link. (I seem to recall something like this existing for Firefox, but it's been a couple of years since I used Firefox regularly and I can't find anything like this in a quick search of their addons page.)

<comment><USER3> Second one already exists.

[https://chrome.google.com/webstore/detail/lacckjdlmkdhcacjdo...](https://chrome.google.com/webstore/detail/lacckjdlmkdhcacjdodpjokfobckjclh?hl=en- US&utm_source=chrome-ntp-launcher)

<comment><USER2> Thanks! I'd searched for something like this on the Chrome site but missed this one.

</comment></comment></comment><comment><USER4> I wish I had something analogous to Multifox, preferably operating on a per- tab basis.

I looked into making something of the sort, but unfortunately the necessary API calls (e.g. notify my extension BEFORE a cookie gets set) don't seem to exist, so any solution using the existing API would be a bit hackish.

EDIT: It may be possible to do at the level of intercepting all HTTP requests in the affected tabs? (No idea if the API allows that, or if it would be a good approach even if it were possible.)

</comment><comment><USER5> Capturing still frames from a youtube video.

I see this being a hard one. I don't even know if that is possible, but I was asked by a designer a couple months ago and he even offered me some money to build that. Taking screenshots from a video source usually render very blurry images, so he was looking for an extension that would do good still images from a video at specified intervals or specific points in time. May be worth trying.

<comment><USER6> A few months ago, I wrote a proof of concept that does this: <https://github.com/deactivated/video-snapshot>. It seems to still work in Chrome 24.

It depends on the HTML5 player and has a few other limitations, but it might be useful for anyone doing something similar.

</comment></comment><comment><USER7> Boolean operators for on-page text finding. E.g., being able to search for "goose|geese", since the pluralization doesn't involve a common root.

</comment><comment><USER8> Not so much an extension, but I would love to be able to have Incognito tabs instead of Incognito windows.

When I'm doing web dev having two sessions in the same browser is great (ie. not needing another browser open), but I often only have one tab in the Incognito window. It would be very useful if I could just have an Incognito tab in my regular window.

</comment><comment><USER9> A better tab management. When I open a lot of tabs, the tab size is so narrow, so it's hard to find the tab that I wish.

<comment><AUTHOR> Try this [https://chrome.google.com/webstore/detail/jnjfeinjfmenlddahd...](https://chrome.google.com/webstore/detail/jnjfeinjfmenlddahdjdmgpbokiacbbb)

<comment><USER9> It's helpful. Thank you.

</comment></comment></comment><comment><USER10> Vertical/Tree Tabs like Firefox has Tree Style Tab.

Quick Tab is an...interesting take on the problem, but leaves so much to be desired. I'd pay money for a good Tree Tab system in Chrome. It is literally the only reason I still use Firefox for my daily browsing.

</comment><comment><USER11> A CSS only craigslist beautifier better than this[1], I made yesterday.

[1]=[https://chrome.google.com/webstore/detail/mafopckhneadngcoag...](https://chrome.google.com/webstore/detail/mafopckhneadngcoagfohhgbeebaphho)

</comment><comment><USER12> Something that hides all the track comments on Soundcloud so the user doesn't have to do it manually on each track.

</comment><comment><USER13> Something that would actually allow Quicktime vids to fullscreen so I don't have to use Safari to fix this problem

</comment><comment><USER14> DownloadAll plugin from FireFox.

</comment><comment><USER15> a syntax highlighter for plaintext gmail emails.

<comment><AUTHOR> you mean for times when someone sends you code as plaintext email?</comment></comment>


Probable Caustic-Crossing Event in MACS1149 Galaxy Cluster Field - <AUTHOR> http://www.astronomerstelegram.org/?read=9097 <comment><USER2> If you ignore the word "caustic", it mostly makes sense.

Can anyone more knowledgeable in astronomy explain the meaning of "caustic" in this context?

<comment><USER3> [https://en.wikipedia.org/wiki/Caustic_(optics)](https://en.wikipedia.org/wiki/Caustic_\(optics\))

[https://en.wikipedia.org/wiki/Gravitational_microlensing](https://en.wikipedia.org/wiki/Gravitational_microlensing)

</comment></comment><comment><USER4> To the layman?</comment>


On Swift's array semantics - <AUTHOR> http://yinwang0.wordpress.com/2014/07/13/swift-array/

<comment><USER2> According to the Swift language guide Strings, Arrays, and Dictionaries are all copied on assignment to a variable. So wouldn't the author's primary assumption (that let a and var b refer to the same array) be false? And this whole issue is null?

[https://developer.apple.com/library/prerelease/mac/documenta...](https://developer.apple.com/library/prerelease/mac/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html)

 _Assignment and Copy Behavior for Strings, Arrays, and Dictionaries

Swift's String, Array, and Dictionary types are implemented as structures. This means that strings, arrays, and dictionaries are copied when they are assigned to a new constant or variable, or when they are passed to a function or method.

This behavior is different from NSString, NSArray, and NSDictionary in Foundation, which are implemented as classes, not structures. NSString, NSArray, and NSDictionary instances are always assigned and passed around as a reference to an existing instance, rather than as a copy.

NOTE The description above refers to the "copying" of strings, arrays, and dictionaries. The behavior you see in your code will always be as if a copy took place. However, Swift only performs an actual copy behind the scenes when it is absolutely necessary to do so. Swift manages all value copying to ensure optimal performance, and you should not avoid assignment to try to preempt this optimization._

<comment><USER3> > According to the Swift language guide Strings, Arrays, and Dictionaries are > all copied on assignment to a variable.

This might've been a recent change in docs. Quoting part of the same section from my copy of the Swift book downloaded a while ago (emphasis mine):

'The assignment and copy behavior for Swift's Array type is more complex than for its Dictionary type…

'If you assign an Array instance to a constant or variable, or pass an Array instance as an argument to a function or method call, the contents of the array _are not copied_ at the point that the assignment or call takes place. Instead, both arrays share the same sequence of element values. When you modify an element value through one array, the result is observable through the other.

'For arrays, copying _only_ takes place when you perform an action that has the potential to modify the length of the array.'

As an aside, it would be nice if Apple offered some kind of change log or a "what's changed" page for Swift docs (though to my knowledge they had made no promises regarding spec stability yet).

<comment><USER4> Revision history for the main Swift book:

[https://developer.apple.com/library/prerelease/ios/documenta...](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/RevisionHistory.html)

Note that you have to delete the book in iBooks and download it again to get the new version.

</comment></comment></comment><comment><USER5> I wish I could upvote this a hundred times; rarely have I seen so well-laid out a post on such a subtle topic. Just as I would form a thought like, "the author needs to explicitly break this down as an issue of variables vs values", they did so.

Part of the difficulty here (and part of why others are having a hard time understanding it) is that immutable arrays and mutable arrays are really two different types, and unlike many other types (which are inherently one or the other), you really want both. A Java analogy is that there are two different string types: String, which is immutable, and StringBuilder, which is mutable[0]; but this is a property of the value, not of the variable. (Other languages have similar string classes, and Swift might well also.) For C++ folks, the distinction between mutability of variable and mutability of value is shown in the placement of "const", i.e. "const foo ∗" vs "foo const ∗" (which of course leads us to "const foo const ∗", and the whole thing is a syntactic mess, but anyway), and object values which are mutable can behave differently from values which aren't even when the underlying type is the same. In your own code in any language, of course, you can design a class so that its objects are immutable simply by not giving the user any access to set instance variables; and if you wanted both mutable and immutable versions, even without particular language support, you could make a MutableFoo and an ImmutableFoo that are copy-constructible from each other.

What may confuse the issue here is the idea that we might want brief syntax for both kinds of array. But whatever the language designers decide, the OP is exactly right to point out that they really, really need to think this through and divorce mutability of values from mutability of variables.

[0] Technically three, because StringBuffer is also there, but that's not relevant to this discussion.

<comment><USER6> This is an excellent post.

A meta comment (not on Swift): the number of new languages with C-like syntax and nothing revolutionary semantically is baffling. Do we really need to master yet another C-like syntax to do X where a library (or an existing language) would have sufficed? Is this the new way to create technological walls?

<comment><USER7> Are you kidding? Swift has a TON of revolutionary stuff over C, including algebraic data types, optionals, destructuring pattern matching, and a lot more. Rust too. There are a ton of new "C-like" languages that are light years beyond C99.

Edit: Not to mention automated memory management!

<comment><USER6> I meant C-like syntax. The laundry list of features you mentioned is present in lots of existing mature languages (not C).

I don't understand the need to create something rickety without significant innovation (over any relevant language (e.g. SML, Haskell, Racket) and not just C).

<comment><USER7> You complained about new C-like languages (C-like in syntax) not being any better than C. I mentioned some ways that new C-like languages (C-like in syntax) are much better than C. Now you're complaining that other languages already had those features. I don't contest that. Doesn't change the fact that your first comment was misguided.

<comment><USER6> You misunderstood my first comment. I meant new C-like-in-syntax have nothing revolutionary semantically _across the board._ This is a double blow as each new C-like syntax is difficult to master (compared to Lispy languages) and contributes nothing semantically new.

<comment><USER7> > You misunderstood my first comment. I meant new C-like-in-syntax have > nothing revolutionary semantically across the board.

Are you saying that the new features in Swift/Rust/C#/etc. aren't revolutionary? Or that they're not "across the board"? Or that they're not semantic? Which part do you disagree with?

> This is a double blow as each new C-like syntax ... contributes nothing > semantically new.

This is demonstrably false. Do you mean that you don't think the new semantics are revolutionary enough? Or "across the board" enough?

Either way I have to disagree with you. Automated memory management is a semantic game changer, and applies nearly everywhere. Same goes for type inference, and optionals. ADTs are huge too. If your argument is that these are not important semantic improvements over C, then IMO you could not be more wrong.

<comment><USER6> Why do you seem so bent on misunderstanding me? I am not talking about semantic improvements over just C!

E.g,

> Automated memory management is a semantic game changer

That has been there in other languages for decades.

By "across the board," I meant across all languages not just C-like languages.

<comment><USER7> Ah! That wasn't clear to me from your wording. I think I was especially confused because that means your argument seemingly boils down to "only the first language to have a feature is notable." (And I guess also that C-like languages are hard to learn?) But all languages stand on the soldiers of giants. I don't look down on Haskell simply because other languages had its features first.

<comment><USER6> Agreed. I am not looking down on Swift. It seems like all the human capital could go into making existing languages more awesome.

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER8> I'd probably prefer that var b = a would just generate an error. You would have to explicitly copy or clone an immutable object in order to create the variable.

<comment><USER9> I'm glad I'm not the only one thinking this. What's the point of Swift being "safer" if this isn't an error (or at least a warning). The standard library even includes -[mutableCopy], so it's a established convention.

<comment><USER10> agreed; this would be a nice exception and I'm sure in a few places the compiler could pick this up to add warnings. Alternatively get it to throw an exception if the array is modified. Much better than some [[]] notation which just makes me think of multidimensional arrays

</comment></comment></comment><comment><USER11> I don't see anything wrong with the beta3 semantics. I see it as problematic that (=) is so casually overloaded between "assign" and "equivalate".

> Now aliasing an array will cause the array to be copied. Isn't that weird?

But assignment to a mutable reference is just that, assignment not equivalation. It is not merely aliasing. We do not desire the ability to freely replace "b" with "a" so why assume it holds?

Sure this might vary from programmer's mental models, but that is the fault of the programmer after a point. I expect all hammers to work roughly the same, yes, but I expect a laser cutter to work under very different principles. I must learn them.

</comment><comment><USER4> I disagree with this post. The semantics are clear and simple: if you assign,maps to a function or return from a function any array you can treat it as a copy of the array. As a performance optimisation the copy usually won't happen as it won't be needed. If you are dealing with large enough arrays that it matters wrap the array in an object that can be passed by reference.

I strongly opposed to original semantics and blogged about it. I am happy with the replacement.

<comment><USER4> Much too late to edit. I should have said "...assign, pass to a function..."

</comment></comment><comment><USER12> Then what is the point of having let vs var at all? I think the solution they came up with is the correct one given the design of swift and its use of let and var keywords.

<comment><USER13> let v var has to do with mutable bindings, value mutability within the bindings should be a separate concern.

Rust makes that exact difference[-1]: `mut` can be used either at the binding level

        let mut a: ∫

or at the type level:

        let b: &mut int = &mut 1;

Both are references (~pointers) to an int, but `a` is a mutable reference, it can be changed to point to a new value[0]:

        a = &2;

because b is an immutable reference it can't point to a new value and

        b = &mut 2;

is a compilation error:

         error: re-assignment of immutable variable `b`

_however_ b's _value_ can be modified in place:

        *b += 1;

whereas trying that with a:

        *a += 1;

is an error:

        test.rs:5:5: 5:7 error: cannot assign to immutable dereference of `&`-pointer `*a`

`a` is a mutable reference to an immutable value, `b` is an immutable reference to a mutable value.

[-1] and so does C though it has the opposite defaults, you can have an

        int const *

— a mutable pointer to an immutable int (you can reassign the pointer but not change the pointee) — and an

        int * const

— an immutable pointer to a mutable int (you can't reassign the pointer but you can alter the pointee)

[0] the code does not work as-is because lifetimes, but close enough

<comment><USER14> I didn't appreciate that Rust makes that distinction, that really is quite elegant.

By way of comparison (to Rust and the original article), here is Scala:

        scala> val a = scala.collection.immutable.Set("apple", "orange")
        a: scala.collection.immutable.Set[String] = Set(apple, orange)

        scala> a = Set()
        <console>:8: error: reassignment to val
               a = Set()
                 ^

        scala> val b = scala.collection.mutable.Set("cherry", "plum")
        b: scala.collection.mutable.Set[String] = Set(cherry, plum)

        scala> var c = b
        c: scala.collection.mutable.Set[String] = Set(cherry, plum)

        scala> b += "pear"
        res6: b.type = Set(pear, cherry, plum)

        scala> c
        res7: scala.collection.mutable.Set[String] = Set(pear, cherry, plum)

        scala> c = a
        <console>:10: error: type mismatch;
         found   : scala.collection.immutable.Set[String]
         required: scala.collection.mutable.Set[String]
               c = a
                   ^

In other words: var versus val has to do with mutable bindings; mutable bindings allow you to mutate the value but not the type; object mutability within the bindings is governed by the object's own type (as the original author recommended for Swift).

<comment><USER15> The different types of mutability are also quite important for the concept of "borrowing" in Rust, which is simply taking a reference. The compiler ensures that ownership of the variable isn't transferred while any such reference is active, and only one mutable reference (of a mutable type) can exist at any one time. This means that bugs like that shown for Swift are impossible in Rust, because the language ensures no two things can ever modify it at the same time.

</comment></comment></comment></comment><comment><USER16> I rather like the copy-on-write semantics of Beta3. And if the OP wants the Swift team to consider his/her comments, they should file a Radar like everyone else.

</comment><comment><USER17> The syntax proposed has problems. Many languages allow you to declare nested data structures and a natural way to express an array of arrays in swift would be the following:

      let a = [[1,2,3],[6,7,8]]

<comment><USER18> Can you give an example for which the proposed syntax would be problematic? Your example would be written as:

        let a = [: [: 1, 2, 3 :], [: 6, 7, 8 :] :]

or

        let a = [ [: 1, 2, 3 :], [: 6, 7, 8 :] ]

etc., depending on what mutability you want.

</comment></comment><comment><USER19> This is not a good solution. This adds complexity (syntactically and conceptually) without adding any feature. The immutability is already implied by the 'let' and 'var'.

Additionally, specifying that the RValue "[1,2]" has mutability is meaningless. The expression "[1,2]" is represented as a constant until it is stored in a variable (it should be represented in the MACH-O constant data section). It is the variable which has the concept of mutability.

The proposal is similar to proposing the following declaration in C:

"int i = const 1;"

Which is meaningless, because the '1' can never be not-const

<comment><USER13> > The immutability is already implied by the 'let' and 'var'.

The immutability of the binding and that of the value are different concerns. let and var are about the binding's mutability, trying to munge them together only ends up in tears.

> The proposal is similar to proposing the following declaration in C:

No. The proposal is similar to the following C:

        int const * i;

</comment></comment><comment><USER20> The proposed syntax creates ambiguity between immutable arrays and mutable arrays containing only a single mutable array.

<comment><USER21> A solvable ambiguity (nested C++ template parameters, anyone?) and besides, it was just an example. I don't think the author really meant to "propose new syntax", but rather say "this is a real problem that needs solving and I'm sure the Swift team can come up with syntax for it if they want it to be succinct".

</comment></comment><comment><USER22> _A similar but more subtle problem happened to Java's arrays regarding aliasing and subtyping a long time ago, which could crash the JVM._

Really? I don't remember that, and i was writing Java a long time ago. I'd be interested to be reminded about this bug.

</comment><comment><USER23> The actual article title is currently: "Design mistakes in Swift language's array"

<comment><USER24> We didn't change it. I assume the rewording was joeyespo's attempt to avoid misleading or linkbait content in the title. As the HN guidelines point out, that's fine.</comment></comment>


Police return BC student's computers - <AUTHOR> http://www.boston.com/yourtown/newton/articles/2009/05/27/bc_student_gets_computers_back/ <comment><USER2> Email rumors are so 2001.

If he wanted to do it correctly he should've hacked into his roommate's Facebook account and changed his sexual preference.</comment>


The Elite School Wage Premium - barry-cotter https://www.aeaweb.org/research/charts/wage-premium-elite-colleges-india <comment> barry-cotter > In theory, the best students go to the best colleges, receive the best > education, and then take the best jobs.

> In practice, this logic might be giving too much credit to elite schools.

> A paper in the July issue of the American Economic Journal: Applied > Economics found no evidence that India's most prestigious colleges offered a > better education. But author Sheetal Sekhri said that they still boosted > earnings.

...

> The jump at zero indicates that scoring just high enough for admission to a > public school increased salaries by approximately 8,000 rupees. To put that > in perspective, entry-level jobs in the sample paid anywhere between 15,000 > rupees and 40,000 rupees.

</comment><comment><AUTHOR> A third explanation is that if you barely got in, you feel as if you aren't smart enough to be a professor, and work unusually hard to be successful in highly remunerated fields</comment>