Hacker News new | past | comments | ask | show | jobs | submit | soldergenie's comments login

RSUs in a highly liquid publicly traded company are pretty close to cash


But still not cash. Cash is king.


I ran into the need for this recently, except for a program written in Java... I really wish the JVM had a 128 bit data type (or at least a muldiv function, in which muldiv(a, b, c) = ab/c, but the intermediate ab result can exceed 64 bits.


You could split A into multiple components (1st to 4th byte, 5th to 8th byte), and multiply/divide those components separately. That would still fit into 64bit.

Partial example is here: https://codereview.stackexchange.com/questions/72286/multipl...


Yeah, I did try that, but performance was lacking. Java, if you stick with primitives and use a C-like programming style (miniminal objects) was pretty close to C performance when I tried it, except for this one gap.


As I read the article, I was wondering if the GCC compiler was converting some of the code to intrinsics?

If this is the case, and I'm not a Java programmer, I was wondering if there is a way in Java to tell the JVM to do something similar and, if so, how does the JVM cope with different CPUs. Does the JVM, on x86-64 for example, know when it can use SSE instructions?


Speaking of hotspot: No intrinsics for >64 bits. Comparing Strings/copying arrays does utilize SSE. There is a minimal support for auto-vectorizing some simple loops. [0] (4y old thread)

[0]: http://mail.openjdk.java.net/pipermail/hotspot-compiler-dev/...


In those cases you could of course opt to write the high-performance bit in C and have Java call that. No reason to stick to one language if performance is critical.


The overhead of calling a JNI function is considerable so this only works for functions that do a relatively large amount of work. There are also a ton of other drawbacks to this related to the fact that you've now escaped the JVM, miss out on the management of memory for those functions (so better make them stateless) and a host of other potential pitfalls depending on what platform you're doing this.

Definitely not an 'of course', and for critical performance if the function is small enough it might actually be slower to write it in C and call it from the JVM.


Indeed, you need a relatively large direct ByteBuffers and optimally paralyze the JNI call to take benefit of multi-core. It's a non-trivial task to get stable performance boosts unless the data volume is sufficient.


write one? it's simple algebra.


The problem is performance when working with an entire object rather than a primitive type.


Your homegrown object wouldn't have any special meaning in the JVM and wouldn't be able to be optimized as a 128-bit integer.


Parent probably means writing the muldiv function, which would return a "basic" 64bit int.


Startup employees which took a pay cut in exchange for equity are going to be the biggest losers. At least VCs and private equity have some level of protection against a decline in valuation from their preferred shares/liquidation preferences. It won't protect them against bankruptcy, but it is a lot better than nothing.

Employee's generally don't have that type of protection, and the liquidation preferences also decrease the value of the common shares after a down round. So even with a relatively modest decline in overall valuations, a lot of employees are going to end up with worthless options/shares after a down round.


Hopefully that will be a good lesson that will hit the next group of young and bright eyed developers.

It's not as if equity is necessarily bad, but unless you are a founder, you have ZERO control over what is going to happen to your equity. If the plan is not to exit after just a few years, you could be stuck for a long time, if just because without an IPO, you won't even be able to keep your equity if you leave, even if it's just because you can't pay the taxes.

I think that educating recent graduates about what are the realistic outcomes of betting on equity. For every early google employee, there are thousands of people whose equity was worth nothing. Even options in big companies can be worth nothing, if they were handed to you at very high prices.

When people learn the real risks, we'll see employees getting either a whole lot more equity, or salaries will go up. Either way, good for the industry.


While there are trends, work culture varies from company to company, and I'm sure you'll find a company in either city with a work culture you will be happy with. The more pressing question is which of these two cities do you want to live in?


Did you have to take a salary cut when you moved to VA? (e.g.: so your salary would be more in line with VA norms than silicon valley norms?)

That is the big problem with telecommuting for me - it seems hard to find companies which are willing to pay silicon valley level salaries to people living outside silicon valley, and if you take a pay cut, the savings in rent diminishes drastically.

I suppose it is different when you start in silicon valley and move elsewhere while staying in the same company, rather than just starting out elsewhere. But that is still an concern since your salary gets reset if you ever change companies without moving back to silicon valley.


Not the poster you're replying to, but I manage both remote employees and local devs. We do adjust salaries based on location, but the adjustment data we use seems skewed in favor of remote employees. As an example, an employee in Florida gets $140k which is only $30k less than we'd pay him if he were local.

> But that is still an concern since your salary gets reset if you ever change companies without moving back to silicon valley.

I'm not sure if this is true. If you're going to work for another SV company and remote, it's quite common for you to be able to quote a number higher than you got from your previous remote job and negotiate your way down to at or just above where you actually were in the previous job. The only time where I'd see you needing to adjust your salary down is if you took a job with a non-SV company in the interim. Just be aware that the salary data used by each company may be different.

But it is probably helpful to come to SV/SF at some point in the beginning and transition to remote work initially because hiring out here is somewhat incestuous and having a well-known SV employer on your CV will help with getting past HR filters and ensure you get the necessary LI touches.


I changed jobs in order to return home from the Bay Area. With my old employer I would have taken a small pay cut, but that wasn't an option since my group did not have a presence in my home state, and the VP my group was under refused to consider telecommuters. I'm not certain what the pay cut would have been (since they were very secretive). There was a guerrilla salary survey which indicated that lower-cost areas did not have substantially lower salaries (maybe 20% less).

With my current employer, I get paid the same regardless of where I live.


Those companies do exist, and they're getting more common.


How is that different from the Visian ICL which has been available since 1996?


That is good to know. Do you have any recommendations for a more mature version of grpc (cross-platform communication with a high speed encoding)? Thrift?


I've never used Thrift. One option I have evaluated is NATS [1], which is a very fast, non-persistent, distributed MQ written in Go, with client libs in all sorts of languages. It's extremely fast and supports RPC-style request/response.

You get load balancing and discoverability for free, since NATS will distribute messages equally to consumers: Just fire up new consumers, and they will get messages to the topics they subscribe to, and all a client needs is the host/port of the NATS server, which is going to be the same for all parties. Couple that with some hand-coded serialization — Protobuf, Msgpack or even JSON — and you have a fairly resilient, fault-tolerant RPC.

You could trivially do streaming RPC if you handled the request/response matching yourself — if you look at the clients, NAT's RPC is all handled on the client side, using ordinary messages with a unique topic name generated for each request/response. Extending it to support multiple replies per request would be simple.

There are other, more feature-rich message queues, of course, such as RabbitMQ. NATS' advantage is that it's extremely simple.

Another option is ZeroMQ, but it's a bit lower-level and doesn't solve the discoverability part. You'll end up writing much more glue for each client and server.

[1] http://nats.io


People ask me why I, a software developer, don't move to Silicon Valley where salaries are high and venture capital is easy to get. The skewed male/female ratio of Silicon Valley is the reason. As an Asian-American male, I have a hard enough time getting a date. Going to the valley seems like the odds would be double stacked against me.


But according to the article, you should move to Manhattan.


That's what I did. And dating here is definately easier than (random medium sized American city). Of course, that might just come from being in a large metropolitan city. Silicon Valley might be the same - I've never lived there - but the male/female ratios indicate the odds aren't in my favor.


Silicon Valley is more of a suburb than metropolis. Though SF is probably similar to NY with respect to dating prospects.


Smart move, good on you!


In addition to being CEO, one of his many other accomplishments was that he was the main programmer for Earthbound, a game close to my heart. A death like this always tragic, but the death of a fellow programmer makes it feel closer to home.


You stand on the left in escalators in Australia, which was confusing at first, as you stand on the right in escalators in the UK, even though both countries are left-hand-drive.


Join us for AI Startup School this June 16-17 in San Francisco!

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: