"When all your engines stop, the flight is over" - <AUTHOR> http://blog.theoldreader.com/post/56209408824/important-update/

<comment><USER2> Honestly, this doesn't sound like a bad batch of drives or the like -- sounds like they weren't doing scrubbing on their RAID.

In case it's helpful, and for general knowledge dissemination:

What likely happened is that a drive "failed". This is usually when the RAID card decides that a drive has had enough command errors that it fails the drive. It may actually be fine, and just had a spate of bad responses. You might try to online the drive again and let it rebuild, but that's debatable.

At any rate, so they replaced the drive. That's fine. But then, to rebuild the RAID back to optimal state, it has to read all of the data off of the other drives. Here's where a bad scrubbing policy bites you -- because if those drives have any sectors that have gone bad or problems with the hardware, those drives might fail as soon as the rebuild runs.

Scrubbing should be done regularly (weekly?). What it does is, in essence, test every sector on all of the disks in the array to make sure that all of them are still fully functional so that -- if there is a failure -- you're pretty sure you can rebuild.

The downside of scrubbing is that, for better or worse, it does exercise your disks fairly heavily. Also, if you don't have a suitable trough period then you might even find it difficult to have the available I/O bandwidth to do it.

That said, you should do it if you're not.

<comment><USER3> I'd recommend ZFS for working with these kind of arrays; scrub is a command that's easy to regularly schedule, and will only use idle I/O bandwidth (helps that the RAID functionality is integrated with the whole filesystem).

If you have an infrequent scrub policy and hit bad sectors on rebuild, it can detect checksum failures and mark specific files as corrupted, rather than declaring all your disks defective. Traditional linux md raid behaviour is particularly bad in this regard: if you have a raid6 configuration and haven't been scrubbing, and then have a single disk failure, all your disks will have a few random isolated bad sectors (i.e. sectors that will URE when you attempt to read them) on, but since you still have one disk's worth of parity it's possible to recover all your data with no downtime (and with ZFS raidz2 this is what would happen). But with md raid as soon as you hit those bad sectors during the rebuild it will consider those drives as failing and kick them out of the array, and since all your drives have at least one bad sector on that means it's impossible to recover the array.

<comment><USER2> Well, scrubbing with md is pretty easy, too.

That said, ZFS sounds great, and I've been meaning to learn it sometime. The big thing holding me off has been just -- well, how much time I've put into learning md and such, and how I would find it hard to justify going back to not knowing much (since this is my livelihood).

If you have any tips on "read this, it's a good intro" stuff (slanted to Linux, as that's my cuppa), I'd welcome them.

<comment><USER3> I'm no expert, just a satisfied user; I got into it from the FreeBSD side, and followed their tutorials, but I don't know how well they'd apply to Linux. In general I like the Gentoo and Arch wikis, particularly for slightly lower- level things like this - even if one is using a different distribution, they tend to take the time and explain the concepts in a way that's mostly distribution-independent.

I will say that ZFS felt very coherent and even - dare I say it - easy. I was worried that merging layers that I'm used to thinking of as separate would mean a loss of control, but I was able to put together all the layouts I wanted. The various commands with a single interface felt a lot like using lvm2 - different tools but under a unifying structure with the same parameters - and a lot of what it does is lvm-like. So my best tip is to approach it more as an LVM that can also do raid-like functionality and be mounted directly, rather than as a raid system that includes volume management.

Sorry if that's not terribly helpful - as I said, I'm not an expert, but I wanted to at least give you some kind of reply.

<comment><USER4> +1 for the Arch wiki. Despite being a distro wiki they have very nice in depth and distro-independent pages. I use Debian but regularly read through the Arch wiki when trying to do new stuff.

</comment></comment></comment></comment></comment><comment><USER5> Reminds me of this (from many years ago):

"But even today a 7 drive RAID 5 with 1 TB disks has a 50% chance of a rebuild failure. RAID 5 is reaching the end of its useful life. "

[http://www.zdnet.com/blog/storage/why-raid-5-stops- working-i...](http://www.zdnet.com/blog/storage/why-raid-5-stops-working- in-2009/162)

<comment><USER6> Although the fail characteristics and sizes of SSDs are not the same as conventional harddrives so you can't really make much out of that article in an SSD context.

</comment></comment><comment><USER7> If you aren't using Intel SSD in a server environment, you are going to have a bad time.

They are too relatively slow for home computer use but for servers, much more reliable.

That said, this chart concerns me:

[http://www.ssdaddict.com/ss/Endurance_cr_20130122.png](http://www.ssdaddict.com/ss/Endurance_cr_20130122.png)

25nm Vs 34nm [http://google.com/search?q=cache%3Ahttp%3A%2F%2Fwww.xtremesy...](http://google.com/search?q=cache%3Ahttp%3A%2F%2Fwww.xtremesystems.org%2Fforums%2Fshowthread.php%3F271063-SSD- Write-Endurance-25nm-Vs-34nm)

My first personal computer SSD is going to be the Samsung 830 from different batches in Raid1

Also, when someone else builds your servers, you should query the smart info from the drive to make sure they aren't used SSD.

</comment><comment><USER8> SSDs still seem to have a bunch of nasty failure cases. Right now, for production use I'm not sure I'd trust the things for reliable storage. As a fast cache for spinning rust? Definitely. As my only live copy, even duplicated in a RAID? Hmm.

Not even Intel SSDs are immune: One of the Debian developers has reported that the SSDs shipped in the latest Thinkpads die if you try and construct an encrypted filesystem on them. Somehow they corrupt themselves during the initial write of random data to the disk.

(Interesting that these SSDs died whilst under high write load too: is this a particular weak point for some reason?)

<comment><USER9> > _SSDs still seem to have a bunch of nasty failure cases. Right now, for > production use I 'm not sure I'd trust the things for reliable storage._

You should not trust anything for "reliable storage". That's what backups and redundant drives are for.

</comment></comment><comment><USER10> Losing data s __but the analogy is flawed.

"When all your engines stop, the flight is just starting"

<comment><USER11> When your engines stop, you trim for best glide ratio, point yourself at an open field, and fly the plane all the way to the ground. Failure to do so is a great way to get yourself killed.

<comment><USER2> Nice to see a fellow pilot -- well, I'm still in the student phase, but I've been doing lots of "glide, grass, gas!" lately, as my instructor likes to say.

Sadly, the number of open fields to aim for in the SF Bay Area is pretty small. It's either hillsides, bay, or city. Oh, and a couple of thin dikes you could land on. ("That's why nailing the centerline is so important. Someday you might need to land on something like that dike wall -- and if you nail it, you walk away fine.")

</comment></comment></comment><comment><AUTHOR> BTW I should add that I'm still a fan of TOR and have no plans to switch away. In fact, their upfront explanation of what went wrong and how has improved my opinion of the project.

</comment><comment><USER12> Sympathies. We had a similar thing happen at a previous job in the days of the "deathstar" drives. Lost a drive, no biggie. Tell the DC guy to replace it. Lost a second drive, told him to start running towards our cage. Lost a third drive, uhh - how current are our backups?

Different job - had a developer accidentally run a where-clause-less delete in production. Same net result. RAID and SANs are definitely not backup solutions.

<comment><USER13> Very much so. For us, raids are mostly time we can use to move all the important data off of that raid. It might be drastic, but it's safe and our data isn't too big.

</comment></comment><comment><USER14> If your service goes down, be sure to at least have some notion of what your service does on the homepage. Right now, it's only an error report and I had to skim through the blog for a while to figure out that it's a kind of Google Reader replacement.

When your engines stop and you're getting lots of eyeballs, don't assume they all know you.

</comment><comment><USER15> Storage is cheap compared to engineering labour. That's a massive migration (from one DB to another), definitely not worth saving that 300gb.

It's still unclear how the storage failure was related to the migration. Was the new engine/fs disruptive to the SSD?

<comment><USER16> They mentioned pretty explosive growth so 300GB today may be 3TB next month and 100TB in a few years.

</comment></comment><comment><USER9> > _When all your engines stop, the flight is over_

Pedantic and off-topic as it is, this is incorrect. At least for airplanes.

When all your engines stop you continue to glide, and you can even manage to land succesfully with a little skill and luck.

<comment><USER6> So, a glide to an emergency landing means that the flight is not over?

Similarly just because a rebuild fails doesn't mean that the data is lost. Just pop in the drives individually and fetch whatever you can from all of them, it is seldom the case that the exact same parts of them become irretrievable at the same time or that the drives stop function completely. It's just some more work than a regular rebuild.

<comment><USER9> > _So, a glide to an emergency landing means that the flight is not over?_

By the very definition of the world "flight", yes.

<comment><USER6> Well, it depends on which definition of flight you use...

</comment></comment></comment></comment><comment><USER17> Ouch, sounds like somebody got hit by a really bad batch of drives. Always a risk when you buy a bunch at the same time. :/

<comment><USER18> In my experience, all SSDs are a bad batch unless they're Intel 520 or Samsung's high end range.

A big mistake to make is to fill an SSD drive completely up with data. This is a huge no-no unless it's an enterprise drive which usually use a totally different design.

</comment></comment><comment><USER19> Either those drives are all from the same bad batch, or this isn't a drive problem. I would be thinking either a cooling problem or flaky controllers, and a drive swap in that case is not the solution.

<comment><USER20> Doubt those drives were from bad batch. As these were SSDs, most likely write wear. Two SSDs should never be in RAID 1 pair or replace at least one SSD in RAID 1 at predetermined schedule instead of replacing on failure only. They are going to wear off at same pace and will fail about the same time.</comment></comment>


Show HN: Anansi – a NoWeb-inspired literate programming preprocessor - <AUTHOR> https://john-millikin.com/software/anansi <comment><USER2> I came to similar conclusions as the author about the usefulness of literate programming. Even after "taking it seriously" and "doing it right" and all those other no-true-scotsman type objections. (see HATEOAS/REST for more examples of these).

Initially, I was super excited about the idea. Imagine a world where you take a book off the shelf and peruse a master programmer's in-depth explanation of the details of some famous software. What they were thinking, the abstractions they decided on, the algorithms they chose, the tradeoffs made. Wouldn't that be an amazing world to live in?

In practice, very few pieces of software are written in a way that lends itself to a cohesive narrative. Software is written by numerous developers, layer by layer, often with hacks thrown in. New people come on, don't understand the whole thing, change parts of it, and move on. The requirements change, and the system contorts itself to serve multiple purposes that weren't envisioned by the original coders.

Keeping normal auto-generated documentation up to date under those circumstances is already a herculean task, literate programming asks more: maintain a story and flow and an overarching rationale. It's just not possible for most software.

There is a type of software that lends itself to literate programming: the kind of software Donald Knuth writes. Written by a single author, with encyclopedic knowledge of the problem domain, excellent writing style (Knuth is very funny if you've read his work), and above all, the programs Knuth writes tend to be "done" at some point. There are bugs to be fixed, but no new features are added that might drastically change the narrative.

Most software isn't like that, but if yours is, then literate programming can be fun.

<comment><USER3> I agree that literate programming works well for Knuth because of the kind of programs he writes: mainly, as you say, that the program was written for a particular purpose, and when that's achieved it's "done".

I wonder, though, whether it's necessarily true that more software cannot be like that. We _could_ in principle move a little more in the direction of declaring programs done, and when new requirements come up, writing a new program to cover them. (Knuth has no qualms about having similar code in different programs; it's almost universally believed by other programmers today that that's a terrible thing.) The old program would continue to work well for its original purpose, and those who need the newer program would use that one instead.

As with books: sometimes you need a new edition of a book, sometimes a reprint with corrections, and sometimes a new book entirely. It's ok if multiple books cover the same topics and even if they do so in slightly different ways; all that matters is that each is internally consistent — we don't demand that everything related to a certain domain and written by the same author(s) be in a single book. With programs, almost always they only grow and expand, with incremented version numbers.

<comment><USER4> > I agree that literate programming works well for Knuth because of the kind > of programs he writes: mainly, as you say, that the program was written for > a particular purpose, and when that's achieved it's "done".

A piece of software in itself really isn't much of anything; the true value lies in the support you get from the development team. "Done" software is inherently unsupported, therefore close to worthless and probably won't be used in a production setting.

> (Knuth has no qualms about having similar code in different programs; it's > almost universally believed by other programmers today that that's a > terrible thing.)

It's a waste of programmer effort. In the open source realm at least, it would be a far more efficient use of programmer time and energy -- and easier on the users -- for programmers to collaborate on a single definitive program for each task, rather than reinvent wheels and confuse the marketplace with competing implementations of the same abstract process.

<comment><USER3> Let's talk specifics. Here are four programs written by Knuth, in roughly chronological order:

1\. The Algol-58 compiler he wrote for Burroughs (specifically, for their B205 machine). You can read about it in many places ([http://ed-thelen.org/comp- hist/B5000-AlgolRWaychoff.html#7](http://ed-thelen.org/comp- hist/B5000-AlgolRWaychoff.html#7) , [https://www.youtube.com/watch?v=QeiuVNDQg4k&list=PLVV0r6CmEs...](https://www.youtube.com/watch?v=QeiuVNDQg4k&list=PLVV0r6CmEsFzeNLngr1JqyQki3wdoGrCn&index=27) , or in great detail at [http://datatron.blogspot.com/2015/11/knuths- algol-58-compile...](http://datatron.blogspot.com/2015/11/knuths- algol-58-compiler.html)). This was written in the summer of 1960, debugged by Christmas, and put on their computers. The machine didn't sell very well in the US, but apparently it (and the compiler) was being used in Brazil over the next decade, successfully. I wouldn't call this "worthless" by any means; it did its job. (Of course one might argue that the prevailing model at the time was for software to get "done", so it wasn't really an exception.)

2\. TeX. This is the most famous example. After developing it for about 10 years, he declared it done ([https://www.tug.org/TUGboat/tb11-4/tb30knut.pdf](https://www.tug.org/TUGboat/tb11-4/tb30knut.pdf)) except of course for bugfixes. (He still looks at bug reports once every few years ([https://cs.stanford.edu/~knuth/abcde.html#bugs](https://cs.stanford.edu/~knuth/abcde.html#bugs)), but there was exactly one bug reported during 2007–2013, and it was a really inconsequential one about the whitespace for how an "empty" macro would be printed in the error logs.) TeX is stable, well-understood (at one point of them there were hundreds of people who "knew" the entire program, which is unprecedented for a program of that size), and is very well-supported (see TUG, tex.stackexchange.com etc) — and in any case most of the questions these days are about LaTeX (a set of macros, with horrible error-handling, the opposite of TeX) or other packages, not about TeX (the program) itself. At Knuth's request, extensions are released as new programs (pdfTeX, XeTeX, LuaTeX) etc, and TeX stays the same (and even these programs have approached stability). This is _definitely_ neither "inherently unsupported" nor "close to worthless" nor "probably won't be used in a production setting" — at any given point of time several publishers are using it in production, not to mention various others who are not even making physical books.

3\. The Stanford GraphBase. This is a suite of programs, also published in book form (as literate programs). There are people still making use of these books, and these programs can be used as building blocks for other programs, e.g. for many of the ones that Knuth writes mainly for himself (see [https://cs.stanford.edu/~knuth/programs.html](https://cs.stanford.edu/~knuth/programs.html) or [https://github.com/shreevatsa/knuth-literate- programs/tree/m...](https://github.com/shreevatsa/knuth-literate- programs/tree/master/programs)). I don't think continuing to work on it, versus calling them done for now, would change anything about them.

4\. Any of the programs on that page, e.g. say SETSET, which was written in February 2001, and "Enumerates nonisomorphic unplayable hands in the game of SET®". Or the first two (SHAM, written December 1992, and OBDD, written May 1996) — both written mainly to find that there are "exactly 2,432,932 knight's tours [that] are unchanged by 180-degree rotation of the chessboard". Once the job is done, just what is to be achieved by refusing to declare them "done"? (Incidentally, note that Knuth did figure out an improvement to SETSET, but wrote it as a new program. The original program is fine though.)

In fact, if you look at the blog post by Joel Spolsky from 2002 on "Five Worlds", in at least three of them (and maybe four), software can be quite commonly declared "done" (always, of course, except for bug fixes: "done" just means we've finally decided what the software is supposed to do; it's not the same as abandoning it even when it's not doing what we decided it's supposed to do). Throwaway code is often indeed thrown away, games get changes released as sequels or separate expansion packs, embedded software often _cannot_ be updated anyway, and internal software can also often be "done". It's only the first one in which it is usually not.

</comment></comment></comment></comment><comment><USER5> > _Eventually the pain of working within a single massive source file became > overwhelming, and I decided to write my own literate programming tool that > could consume a filesystem hierarchy_

I wonder if that's where they went wrong.

Perhaps when your code is too big to fit in a file, it is too big to describe serially at all. And it's time to split it in two separate pieces, two modules with a formal interface between.

The idea that you could have a nonlinear narrative without any formalism dictating the relationships between paths is perhaps asking too much of the narrative form.

Perhaps that's the whole point of a module system: creating formalisms so that you have a chance at holding in your head the relationship between one series of procedures and another.

(This is not entirely academic. I have about 100 richly connected single file modules on NPM)

<comment><AUTHOR> > _Perhaps when your code is too big to fit in a file, it is too big to > describe serially at all. And it's time to split it in two separate pieces, > two modules with a formal interface between._

I'm not sure these two issues are related. The "tangled" PDF output of haskell-dbus 0.9 was split into chapters, each chapter being roughly a single Haskell module (with a specified API). And books are by nature serial, yet they can express enormously complex ideas -- think of a compilers textbook.

This was all six years ago so my memory's a bit fuzzy, but I remember feeling lost in my own code when it was all in one file. I couldn't do things like "split window and go to top" to find the imports/exports of the current module, and searches for a symbol name return far noisier results when they're all implicitly project-global.

It might be possible to fix these with better tooling, like an editor that could parse literate source and show the rendered output. But then you'd be treating the "source" as a sort of opaque input and editing at the level of "compiled" output, which is behavior I associate more with reverse-engineering than typical software development.

<comment><USER6> > And books are by nature serial, yet they can express enormously complex > ideas -- think of a compilers textbook.

I'd argue that, in many cases, well-organized books have split their material up into chunks with formal interfaces between them. A textbook's table of contents and introduction create a high-level structure, cross-references allow like material to be grouped with like material to make a coherent picture of each subsystem or topic, and chapters can be read out of order or even skipped entirely by some readers. Textbooks for mathematics or computer science are the most obvious examples, but I find the same level of organization and ability to jump around even in popular science books and philosophical discourses. Even the simplistic "five paragraph essay" that is taught in elementary school can be interpreted as an implementation of a formal interface.

<comment><AUTHOR> All of that is true of a single source file too -- editors can generate tables of content and cross-references. The experience of using a well-organized paper encyclopedia and Wikipedia are fundamentally different. The point of "serial" is that if I want to read a book, I have to pick an origin point and then start scanning linearly. There's no search bar in a textbook.

</comment></comment></comment></comment><comment><AUTHOR> I saw [https://news.ycombinator.com/item?id=17483242](https://news.ycombinator.com/item?id=17483242) ("Literate Programming: Empower Your Writing with Emacs Org-Mode") and figured HN might be interested in a real-world attempt to use literate programming for a larger project (Haskell implementation of D-Bus).

<comment><USER7> Very candid. I've written before about how Literate Programming gets misused: [http://akkartik.name/post/literate- programming](http://akkartik.name/post/literate-programming)

This feels like supporting evidence.

<comment><AUTHOR> Not misused -- I think I gave a pretty good shot at writing literate code as Knuth originally intended it. It's just that the goal of literate programming, the transformation of source code into a document that can be read like a book, doesn't seem to be useful.

It's worth noting that Knuth wrote WEB in 1981, ten years before the web. There's no way he could have known at the time that hyperlinks and search would be a far more useful interaction model for reference documentation.

<comment><USER7> I don't think this is right. In Knuth's own words at the top of his site:

 _" The main idea is to treat a program as a piece of literature, addressed to human beings rather than to a computer."_ ([https://www-cs- faculty.stanford.edu/~knuth/lp.html](https://www-cs- faculty.stanford.edu/~knuth/lp.html))

This is the consistent message I've gotten from his writings: the goal is to communicate to other people. "Transformation of source code into a document that can be read like a book" feels far more low-level than that.

> Knuth wrote WEB in 1981, ten years before the web. There's no way he could > have known at the time that hyperlinks and search would be a far more useful > interaction model for reference documentation.

Knuth certainly knew about hyperlinks. On the same page, Knuth says:

 _" The program is also viewed as a hypertext document, rather like the World Wide Web. (Indeed, I used the word WEB for this purpose long before CERN grabbed it!)"_

There's a pleasing non-linearity to Knuth's creations, both in the source (with fragments being named and referring to each other) and in typeset form (with all the attention to the index of fragments, to showing with each fragment all the places that refer to it).

\---

In any case, we may be splitting hairs here. I'm not a scholar of Knuth's work, and maybe your interpretation is correct. I agree that if you define Literate Programming as "transformation of source code into a document that can be read [linearly] like a book", then that goal is not useful. If you define it as "better communicating programs to other people," then I think that goal is still relevant. All programmers should keep this goal in mind, while loosening their grips a tad on the precise details of how they happen to aim for the goal at a specific point in time. There's still lots of room for improvement.

<comment><USER8> Hi Kartik! Still at it I see...

me too ^_^

</comment></comment></comment></comment></comment><comment><USER9> See also [http://literate.zbyedidia.webfactional.com/](http://literate.zbyedidia.webfactional.com/) and [https://github.com/zyedidia/Literate](https://github.com/zyedidia/Literate) for information about "Literate", which is my favorite Literate programming tool.

</comment><comment><USER10> I've also tried several times literate programming. I actually like it for small libraries that requires a good documentation but little maintenance.

What I like in this experience is how literate programming forces me to spell out each of my assumptions and justify every choice, just because I then have to program with the reader in mind. And I found that sometimes those assumptions were not as sound as I though. For that reason I would recommend anyone to give it a try.

By the way, I also had to write my own tool, extracting the code from the documentation instead of generating both code and documentation, which allowed me to use both my favorite document format and programming language.</comment>


Alibaba owned paper calls for takedown of great firewall - <AUTHOR> http://www.scmp.com/comment/insight-opinion/article/2102079/time-tear-down-great-firewall <comment><AUTHOR> interestingly this op-ed is written by a paper that Alibaba owns</comment>


In Puerto Rico, Teachers' Pension Fund Works Like a Ponzi Scheme - <AUTHOR> https://www.nytimes.com/2017/03/08/business/dealbook/puerto-rico-teacher-pensions.html <comment><USER2> > One study found that more than three-fourths of all American teachers hired > at age 25 will end up paying more into pension plans than they ever get > back.

You're welcome kids - we've been stealing your money for the last few decades by ignoring basic economic facts. As a result of our greed, instead of getting _more_ out of your retirement savings than you put in (you know, from things like compound interest and investments), you're paying for the previous generation's unsustainable pensions. And of course since we've backed ourselves in to this corner, we can't let you opt out of the pension plan so you can behave responsibly on your own..

<comment><USER3> This is what worries me about most such pension systems[1] -- because they don't operate on an actuarially sound basis, but depend on there always being enough payers, they are prone to "evaporative cooling"[2], which can strike suddenly and without warning.

That is, as you keep goring a larger chunk out of newcomers, you make their alternatives more attractive e.g. occupations other than teaching, or teaching in other country. This looks disproportionately appealing to the biggest potential contributors. So each person that leaves means a bigger chunk you have to take out of other newcomers, and the process accelerates. So then you may have little warning before you reach the point where enough have left to make it bankrupt.

Unfortunately, it's an uphill battle just to convince people that pensions should required to be funded at all, i.e. they set aside the discounted present value of every future dollar promised, rather than "oh don't worry, we'll totes have enough rev by then!".

[1] i.e. pay-as-you-go or underfunded

[2] To explain the metaphor, "Evaporative cooling" refers to how the exits from the system are lopsided and change its average properties. For liquids, the particles that evaporate away have the highest energy per particle, leaving the average particle energy -- and thus temperature -- lower.

<comment><USER4> I'm from Australia and here is my pet hate.

Over here we have compulsory Superannuation Funds where 9-10% of your salary is deposited into your superannuation fund of your choice. Although you cannot access the superannuation fund until you turn 80, and this figure keeps getting pushed back. The business tax rate is 30%, and also employee tax rate for me is 25-27% of my income goes into income tax.

We get shoved down our throat's that we shouldn't be a burden on the tax payer, and will have to provide for our own retirement using our own superannuation funds. Well at the same time being faced with the following situation.

27% of the wages go into tax. 9% of the wages go into superannuation fund for retirement. 2% is the medicare levy that you have to pay per year. 5% or $70 per week for Private Health insurance or you get health insurance loading after 30 years old that accumulates 2% per year.

Then we're faced with a situation where housing is 8-9 times medium income in this country.

So in summary, you're faced with indirect costs to about 43% of your gross income. So take my situation for example 85000+(85000*0.09) gross income the take home at the end of the year is 52,810.5.

Considering a house is now 8-9 medium income, this comes to $680,000 for a average 3 bedroom house. Using a full time income to pay that mortgage @ 4.5% PA ($96 going to fees and associated council rates) weekly repayment of $919 this will take ~ 23 years to pay the mortgage off with the total cost of the loan being $1,086,386, and total interest payable. $406,386.

So fast forward, forward 23 years I'm 58 with $175,950 in the super fund. Assuming a 3% growth of the value of the house, it would be now worth $1,382,299.

The only realistic option for the remainder is to save for the next 20 years until I can access the superannuation (if its around)

$344,250 in super payments $1,284,081 in savings, $2,496,588 house value at the time of retirement and medium wage would be ($277,398)

So what does this say about the Australian economy? Well everyone is banking their house will pay for their retirement that they would draw down on in later years. If by any chance house prices go through a major correction here the whole system will be thrown into a massive shit storm.

<comment><USER5> This is so on point.

The entire economy seems to be driven by housing in Australia.

Its a massive ponzi scheme with developers making the big bucks and the tax system geared to assist investors at the expense of first home buyers.

If housing crashes there will be a lot of very angry people in this country. Developers and governments need to wake up.

<comment><USER4> Wait until the May 2017 budget. The government may announce co-payment or tax incentive to keep the system going. For my situation I will jump and purchase a new house if I can deduct interest repayment from my taxable income. It would level the playing field where as a investor you can deduct interest repayments from their taxable income but as a owner occupier you cant.

I get a bit emotional about this because I went got a CS degree in 2000 and my colleagues quit high school at year 10, and purchase a house in 1998 for $80,000 and in 10 years time that same house was now worth $450,000. In that time they've leverage themselves with 2-3 investment properties. They pay less tax than I do and simply because they got in before the massive housing boom.

Yes I'm pissed about the whole situation.

<comment><USER4> Turns out the May 2017 budget has been announced and the headlines are:

`The federal government has given the go-ahead for a scheme in which the private sector would be given access to cheap capital in return for building more community housing.`

So no alteration to stamp duty, negative gearing, or capital gains tax discount.

Oh well....

</comment></comment></comment></comment></comment></comment><comment><USER6> I don't see anything in the article mentioning a huge factor in Puerto Rico's poverty, the Jones Act.

It requires all goods that Puerto Rico buys be transported on an American made ship(as in built in an American shipyard), staffed with an American crew, jacking up prices.

It causes a crazy situtation where Puerto Rican company will ship their goods to the mainland, and THEN ship them back to the island, so that Puerto Ricans can buy them.

Puerto Ricans don't have decent representation in the national government, so they have no hope of getting it repealed.

Shipping companies LOVE the Jones act, Puerto Ricans hate it [http://www.businessinsider.com/r-us-shippers-push-back-in- ba...](http://www.businessinsider.com/r-us-shippers-push-back-in-battle-over- puerto-rico-import-costs-2015-7) "The report found that the price of imports from U.S. states was at least double that in neighboring islands like the U.S. Virgin Island, which is not covered by the act."

[http://www.fundacionlibertadpr.org/single- post/2016/09/14/Th...](http://www.fundacionlibertadpr.org/single- post/2016/09/14/The-Jones-Act-and-Puerto-Rico%E2%80%99s-Economy)

Richard Wolff interviews Professor Ian Seda of John Jay College on the legacy of colonialism and the Jones Act in Puerto Rico: [http://www.democracyatwork.info/eu_puerto_rico_s_crisis_is_s...](http://www.democracyatwork.info/eu_puerto_rico_s_crisis_is_systemic)

<comment><USER7> Puerto Ricans have had numerous opportunities to change their situation, most recently in 2012. The results were ambiguous.

[https://en.wikipedia.org/wiki/Puerto_Rican_status_referendum...](https://en.wikipedia.org/wiki/Puerto_Rican_status_referendum,_2012)

Puerto Rico actually has a pretty good deal - no federal income taxes. I'd happily give up my right to vote for the same benefit.

<comment><USER8> Can I move from California to Puerto Rico and stop paying federal income tax?

<comment><USER9> Absolutely.

<comment><USER10> Wait? This is true in all cases? I thought the US government required you to pay income taxes after a certain income point even if you were in foreign countries.

Why would Puerto Rico, which is part of the US itself, be an exception?

<comment><USER11> Because foreign countries are not explicitly exempted, while PR is due to past agreements. Note that you have to live there for a good amount of the tax year to qualify, which is fairly typical.

</comment></comment></comment></comment></comment></comment><comment><USER12> Not to put too fine a point on it but...

> In Puerto Rico, for instance, the pension funds are so short of cash that > money contributed by working teachers basically flows straight out to > retirees. ... That is, essentially, a Ponzi scheme.

Is that different by anything but degree than the US federal Social Security system?

> Puerto Rico... ran off the rails by using debt to spend beyond its means. > Year after year, the government could not balance the budget and borrowed > instead

Is that different by anything but degree than the US federal government?

<comment><USER13> Currently, social security takes in $801.6B in revenue and pays out $750.5B a year, and social security has a $2.8 trillion trust fund. After 2022, outflows will exceed inflows, and social security will have to draw down on that trust fund, which will be exhausted by 2035.[1]

From the charts in the NYT article, Puerto Rico's fund is taking in <$400M a year and paying out >$600M, and their trust fund is less than $1B, and will be exhausted by 2020.

Social security is still running a surplus, and still has a massive trust fund. It definitely seems plausible to make changes that will make it solvent well into the future.

[https://www.ssa.gov/OACT/TRSUM/index.html](https://www.ssa.gov/OACT/TRSUM/index.html)

<comment><USER14> > social security has a $2.8 trillion trust fund.

That trust fund is in form of IOUs from the general fund of the Federal government - where do you think the money to pay back those IOUs will come from?

<comment><USER15> Probably taxes, where all SS funds have always come from.

<comment><USER14> That's the point. If the IOUs have to be repaid with extra tax revenues, it is functionally equivalent to a deficit and not really a "trust fund."

</comment></comment></comment></comment></comment><comment><USER16> In Sweden most of the national pension system [1] is a Ponzi scheme, in the sense that there are no invested funds: money flows straight from working people's taxes to retirees pensions.

So far it has worked fairly well, but I guess that's what they say about all Ponzi schemes. :P

1\. All except the so-called "Premiepension". See e.g. [https://www.pensionsmyndigheten.se/forsta-din-pension/om- pen...](https://www.pensionsmyndigheten.se/forsta-din-pension/om- pensionssystemet/finansiering-av-pensionssystemet).

<comment><USER17> They work well, until they don't.

</comment></comment><comment><USER18> My wife is a teacher in PR. She is paying her pension but knkws wont be able to use it. This is the cherry on top of an education system that has _me_ paying for the costs of running her classroom and even the cost of her students' materials costs. I do it for the kids, so that they have a betyer chance in life. But damn how it hurts to see politicians and department officials walk around with millions in their pockets while I spend my heard earned money (that has been taxed) on things they should be making sure are provided. How thry expect schools to work without paper, pencils, toilet paper, light bulbs, or books is beyond me.

And now, well, they are looking for ways to cut costs and benefits to teachers. Fucking assholes.

<comment><USER19> >How thry expect schools to work without paper, pencils, toilet paper, light bulbs, or books is beyond me.

They don't. Somewhere along the line, they noticed that if they don't provide these things, teachers and parents would do it out of their own pockets because they care about the children.

They realized that they could consume the latent altruism of the moral stakeholders for their own enrichment.

<comment><USER18> Food for thought

Most teachers in my wife's school _do not_ buy any materials and do without. They go all year with the initial batch of materials the department sends them (which is a small quantity).

I used to work in EdTech and the situation in many other states is similar. In fact, I know certain big companies who will not even give some districts the time of day because they know any time spent there is wasted. That's how the next generation is being educated.

</comment></comment></comment><comment><USER20> If this general issue interests you, pensiontsunami.com is a great aggregation of stories about it.

Long story short: defined benefit pensions are the biggest financial catastrophe in history, with the worst cases exacerbated by self-dealing between government employees and elected officials.

</comment><comment><USER21> I hare to say it, but most pensions are headed this way due to mismanagement, and lack of revisitation of rates vs payouts over time. Most companies have already eliminated theirs in good faith, or desparation.

</comment><comment><USER22> The thing about math is that you can't reason with it, hide it, debate it, or pass laws that make it untrue. Eventually, pension systems with poor structures collapse, and a lot of people get hurt.

</comment><comment><USER23> In Puerto Rico only?

</comment><comment><USER24> Aren't social security and many/most pensions ponzi-like? And all underfunded?

<comment><USER25> Not by design, but some end up that way due to looting.

</comment></comment><comment><USER26> This is why the estimates of total US government debt are in the ballpark of 50 trillion USD, instead of the official almost 20 trillion.

They're on the hook for all the unfunded liabilities like federal pensions, and are expected to take on bad state and municipality debt, much of which is also pensions.

Puerto Rico is the most recent example of this, and it is why - funny as it may be for other reasons - California will not secede.

</comment><comment><USER27> Social Security too

</comment><comment><USER28> so is all of our medicare and social security...

</comment><comment><USER29> To be fair, the entire economic system is just an elaborate Ponzi scheme.

<comment><USER30> I see you got downvotes, but any semblance of a distinction has been lost. Whatever legal standard federal agencies have used to shut down private versions of these has been totally muddied revealing the moral relativity of all institutions that slowly pay your money back to you.

So yes, today, in 2017, "Ponzi" is used as a pejorative, and comparing accepted good things to a pejorative will garner you downvotes, but there is no distinction.

</comment></comment><comment><USER31> Holding a USD makes you a creditor. A Dollar is 1.5 grams of gold, but it used to be a quantity of silver. So it's _all_ a big ponzi. USD, EUR, JPY, BTC, et al. - sell them as quickly as you get em. There are ways now to hold insured gold that can be withdrawn at ATMs in a jiffy. Or be a sucker.</comment>


Stop hating Java - <AUTHOR> http://andrzejonsoftware.blogspot.com/2011/07/stop-hating-java.html <comment><USER4> I think a lot of the Java hate is because of the architecture astronauts who hijacked the language in the last decade - J2EE/EJB, the GoF, FactoryFactoryFactory shit and so on. I remember seeing the earlier versions of the servlet API and it was very elegant and well designed; unfortunately once the astronauts were through with it writing Java web apps became such a form of mental torture (Struts, anyone?) that even PHP was a welcome relief, let alone Rails. My hate for it came from having to use some shitty app server like WebSphere because the coding-averse CTO considered it a "standard".

Looking at more recent work such as the lovely Play framework and the influence of new JVM languages such as Clojure and Scala, it looks like things are improving in Java-land. It's still a bit dated and clunky compared to Ruby and Python (let alone Clojure/Scala or even Groovy) but it's not as bad as people make out.

<comment><USER5> ... architecture astronauts who hijacked the language in the last decade - J2EE/EJB, the GoF ...

Thank you for writing this. When I first read the GoF Design Pattern Book I thought "this is the reason, why the code in my project is bloated, unmaintainable and shitty".

<comment> St-Clock You are right. The GoF only promoted bloated code. Who in their right mind would use patterns like the Observer, the Adapter, or the Visitor?</sarcasm>

Not sure if you know the history, but the authors of the book really only collected the patterns that they had seen around them in Smalltalk and C++ code. They wrote a catalog so we could all refer to the same name instead of using different names for the same concept. They identified the common problems that these patterns tried to solve and they also identified the trade-offs. Oh yes, they identified trade-offs!

Unfortunately, many developers thought that they had to put as many patterns as possible in their code, which was not the intent of the GoF. Ralph Johnson said that they received emails like "I have now used 15 patterns in my project, do you think we should use more?"

Andrzej mentions in his blog post that Java (and C++) lacks dynamic capabilities so this is why sometimes, you need these design patterns to make your code more easily extendable. Other patterns are good even with dynamic languages (observers...).

<comment><USER6> > Observer, the Adapter, or the Visitor

It depends on the programming language one uses, really. You won't find many references to these patterns on Python's mailing list (or at least I didn't when I was new to the language and used to spend a lot of time there, ~6-7 years ago). Also, when I've tried to learn Lisp or Erlang I didn't find any mentions to such particular patterns (or maybe only in passing), the focus was on something else. And I'm sure there are a lot of other languages outhere who don't bother with patterns.

<comment> St-Clock You did not hear about observer, but you probably heard about publisher/subscriber (most gui frameworks use this, even wxPython with pubsub).

Adapter is a generic name. Compatibility modules that enable python code to run with python 2 and python 3 are adapters. For example: [https://github.com/bartdag/py4j/blob/master/py4j-python/src/...](https://github.com/bartdag/py4j/blob/master/py4j-python/src/py4j/compat.py)

As for the visitor pattern: [http://docs.python.org/library/compiler.html#module- compiler...](http://docs.python.org/library/compiler.html#module- compiler.visitor)

</comment></comment></comment></comment></comment><comment><USER7> First, let me point out that once again we are comparing Java - a runtime, a language platform and an entire ecosystem comprising many frameworks - <USER2> Rails, a specific web framework designed with a specific philosophy (opinionated defaults that work in 90% of cases, YAGNI, etc.) for a specific range of uses ("rapidly prototyping a small-to-moderately sized web site").

So just because Rails developers hate something doesn't mean it's generally evil. It might just be wrong for Rails. Many things are; otherwise Rails would have no texture. Saying no to things is what design is about.

Now let's talk about hate. Everyone hates something. There is nothing wrong with hating things. Hate is just personal taste turned up to eleven. You should strive to hate politely and with grace, to realize that other people love the things you hate and are nonetheless human, and probably even smart. And you should strive to remember that there's an important difference between the things you hate and things that objectively suck. Java, for example, does not suck. Not always. Lots of work has gone into it. Lots of Java-based tools are essential. There are big classes of problem for which Java is currently the best solution.

Nonetheless, I hate Java. It is a handy mental shortcut, one that has yet to lead me astray. My belief is that the problems for which Java-the-language is the solution are problems I don't want to work on, and that I don't have enough time in my life to address the problems I _do_ want to work on, so I should simply develop a Java allergy that kicks in whenever I see the generics syntax and that causes my eyes to water until I flee towards fresh air. It works well.

(What's sad is when you find yourself hating something that _is_ smack-dab in the middle of a set of problems that you want to work on. Hello, PHP! This requires a much richer set of coping techniques than simple allergic avoidance.)

(And, of course, Java is not just a language, and JRuby appears, from the outside, to be awesome, and my curiosity about Clojure is rising, so I may soon temper my simple hatred of Java into a rich melange of love and hate. The stuff of which novels are born, really.)

<comment><USER8> I agree with the you. While it's mean, I dislike the current state of the Java community for the reasons zeemonkee stated in <http://news.ycombinator.com/item?id=2793472>

The tough part about languages like Scala and Clojure is that the existing Java ecosystem bleeds through heavily. For instance, while Scala boils away a lot of repetitious code, it's still there under the hood. It feels like an architectural band-aid. That may change as the ecosystem around each language evolves and writes frameworks and libraries in Scala/Clojure rather than reusing them from Java. However in Scala's case it's as if the language is being marketed as the next evolution of Java-as-a-language with a heavy emphasis on reusing existing Java frameworks and libraries, so I expect the people writing code in the existing Java community to migrate to Scala.

Elitest? Maybe. But I think it's a realistic view.

The newer JVM languages are great if you already have an existing Java codebase, however I'm struggling to find sound reasons to use Scala on a geen field project.

<comment><USER9> Don't underestimate the JVM ecosystem, plus you have 15 years of optimization in the VM...

</comment></comment></comment><comment><USER10> All you need to do to experience this first hand is go to one Ruby meetup. The roundtable introductions at my local Ruby brigade are often seasoned with AA- like declarations of soberness such as "Hi, I'm So-and-so and I've been Java- free since 2006." As a Java pro (and someone who really does like Java) it's a little disheartening. On one hand I know they don't really mean to belittle the technology that pays my bills and feeds my family, but there's a definite mindset of superiority among some professional Ruby-ist communities.

<comment><USER11> I work in what is essentially a Java shop and the opposite is true for me. The Java programmers work on the data set and provide me with an API. My responsibility is to present the data using a Rails application in a sound UI and in the fastest way possible.

They often make remarks about how Rails is easy and Java programming is where real men make their mark.

I think this comes down to a need for people to feel proud about the tools they use and the things they make.

<comment><USER12> The opposite is true for me too.

I've had an Enterprise Java guy telling me once that "programming and Object Orientation got lost with those simpler, easy-to-use language and frameworks", referring to Ruby and Rails.

I dunno about that. Alan Kay would probably say that it got lost with C++ and Java, but YMMV.

Also, one word: speed.

But... I don't really think it boils down to this, it's not like one is better than the other. Proof is that both communities are learning from each other, and there's also JRuby... it's a great thing.

<comment><USER13> > I've had an Enterprise Java guy telling me once that "programming and Object > Orientation got lost with those simpler, easy-to-use language and > frameworks", referring to Ruby and Rails.

You did tell him Ruby is roughly as old as Java, Python is older and Smalltalk predates Java by almost 15 years right?

<comment><USER14> The comment doesn't seem to involve when the languages and frameworks were respectively created, though if you do look at the pairings (Ruby w/ Rails, Python w/ Django as large examples), they are relatively new after all.

</comment></comment></comment></comment></comment><comment><USER15>
      "Refactoring came to us from Java"

Maybe the word came from the Java community but people have been carefully restructuring code since code was invented.

<comment><USER16> It didn't. The wiki tells us that it was first used in 1990, somewhat before Java was on the scene.

<http://en.wikipedia.org/wiki/Code_refactoring#History>

<comment><USER17> Right, [http://books.google.com/books?id=1MsETFPD3I0C&lpg=PP1...](http://books.google.com/books?id=1MsETFPD3I0C&lpg=PP1&hl=ca&pg=PA71#v=onepage&q&f=false) It actually came from Smalltalk, just for a change.

<comment><USER18> Well, Unit Tests also came from it (SUnit was the first Unit Test framework). Which is unsurprising, as refactoring without unit tests is quite daunting.

But JUnit did make them mainstream, and so did Eclipse' refactorings.

<comment><USER19> Interestingly, refactoring usually works quite well for functional Haskell code without tests just relying on the types. (Of course the types won't help you in more imperative sections of your code, i.e. it's hard to guarantee a specific order of actions in the IO Monad with types only.)

<comment><USER20> You mean just like in Java?

<comment><USER19> Yes. But the pure part of your program tends to be bigger in Haskell than in Java.

<comment><USER13> And the type system (and compiler) help you know what's pure and what's not.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER21> We seem to have a rather short institutional memory. It wasn't that long ago (Java's only as old as Ruby) that Java was new and hailed as a savior from C++ and C. Java was widely seen as a great language, or at least a language that presented a great improvement over the existing mainstream languages. It gave GC to the masses for the first time. It delivered standard-sized primitives, an (almost) everything's-an-object design, a cross-platform runtime, JIT compilation, and a host of other improvements to mainstream programmers for the first time. Java has a lot of issues, but in the grand scheme of things, it's a pretty good language.

Stroustrup was dead on: "There are only two kinds of languages: the ones people complain about and the ones nobody uses." The more popular a language is, the more people will complain about it. (And the more people will build crappy software around it.)

<comment><USER13> > Java has a lot of issues, but in the grand scheme of things, it's a pretty > good language.

Definitely not. Especially not in this day and age. Java has a pretty good language, java has a good ecosystem, java has a passable standard library, but in 2011 java is a crummy language.

<comment><USER21> Depends on what you want to do. Want to hack together a low-traffic website quickly? Java's a pretty poor choice. Want to build large-scale systems that are reliable and fast? Java might fit the bill pretty well. It's no coincidence that Google builds much of their infrastructure on Java. It's no coincidence that Hadoop is written in Java. And it's no coincidence that Twitter is rewriting much of their infrastructure in Java. Java is a good language for building Big Stuff.

</comment></comment></comment><comment><USER22> It's been my experience that most people who put down Java or C++ or [your language here] have never seriously used the language and are insecure about learning a new language so they make fun of other languages to hide their insecurity.

Edit: I'll also add that this is not limited to the Ruby community.

One last edit: General Patton once said, "Find what a man is cynical about, and you will know his weaknesses." or something like that. I think that quote applies here.

<comment><USER23> Ok, I'll bite. I think insecurity is different than dislike.

If you asked me today what language would I use for a new web project, I don't think I'd pick a C based language. I don't really have much against that class - I use Objective-C every day. But I think it really comes down to the frameworks and libraries.

I spent the better part of the dot com coding in Java and C++. Towards the end of my Java days, the time it took to get ideas from paper to usable screen with JSPs, Spring, Hibernate - for one developer - seemed like forever. To make matters worse (and not so much Java's fault), I normalized the shit outta the database (a dba would have loved it) and having that fine grain of a data model just added insult to injury. So when I look at 'Java hate', I don't per say outright hate it, but I'm adverse to using it - especially for anything web. If you have a nice SOA, then I could see maybe using it for some services.

The last Java coding I did was in 2006 - that was my last Java contract client. After that, I switched to Ruby/Rails and that was that. A typical story I'm sure. Do I go to meetups and bash Java? No. Is the "eww, that would be like Java" heard around our office (current company is a Rails shop)? Yes.

However, my current company is hitting a ceiling with Rails. The fat model paradigm is starting to break down. Like us, as your project/app/company starts getting bigger and bigger, you start to hit growing pains with Rails. So I've been looking back at my Java history to find other patterns that were used to take some of the weight off the models and Modules where people have been putting things. Basically, Rails (IMO) is great to get you to a certain point, but after your system grows to a certain size, you have to start thinking about other ways to architect it. I think this is where SOA comes in and the data exchange is all done via json.

Would we consider using Java for any service? Probably not. Why? Because of the time and resources required to actually deploy the services. Like TFA says, Java picked XML. If someone actually made a simple app server where apps could be setup and deployed via _properties_ (remember those?), then that might take some of the Java deployment sting out. Or, maybe if our team grabbed a dedicated release engineer, that might help.

So in the end, I don't think of myself or anyone I work with insecure about learning a new language. Most of the devs I work with came from a Java background. What makes more sense is being able to iterate very quickly over your ideas and just get shit done. This is why Ruby/Rails has been so successful. I don't find being cynical about Java a weakness at all. What would be worse in my mind is to get someone in who is not productive with the tools they're using. And for me writing web apps, I just don't feel productive using Java and its associated frameworks/libs/tools/servers.

<comment><USER24> If you ever do want to try out a new app server, what I do is use embedded Jetty. It's not an app server that you deploy your web app to, but rather your web app becomes a runnable application. This makes deployment to something like EC2 completely trivial. Just copy your app there and hit run.

</comment></comment></comment><comment><USER25> Java is awesome purely because of the large corpus of useful libraries. Apache, stanford NLP, etc. Universities and open source groups contribute a large amount of Java code and it really pushes the boundaries of the types of applications you can create that are mature and perform well.

Other than that I develop much faster in Python or Javascript. I've come to love treating functions as first class objects, and I just don't love static typing that much anymore.

Getting my projects done more quickly has become more important than anything else. It just so happens that other languages than Java are better for that.

<comment><USER19> I felt the same about static typing when I first learned Python and Scheme. But I encourage you to give non-crappy static typing, like in, say, Haskell, a try just to broaden your horizon.

</comment></comment><comment><USER26> Java as a language is decent. It's boring. It is stagnant. I expect very little of it.

Java EE is an atrocity and it is just an over-enginnered pile of garbage.

Try play framework. I just finished a webapp in play and the whole experience has been awesome. IntelliJ + Play + MongoDB is AWESOME.

I haven't messed with the Scala version, but I can imagine that Scala + Play is even more interesting. Either way, Java EE/EJB/XMLHell is probably my most people hate Java. Also, Swing was garbage too, but who builds desktop apps in Java anymore anyway?

<comment><USER27> Play! Scala is really, really, really cool. The major downside--drink if you're expecting this one, folks--is the recompile time. Building an app is just so bleeping slow.

But writing it? Very nice, aside from the somewhat iffy SQL layer. (I'm not a huge ORM fan, and the process of actually writing SQL through Anorm can be problematic.)

<comment><USER26> For our app, we went straight up MongoDB driver. We didn't mess with an ORM at all. We still have our objects that end up mapping to Mongo, just not using a 3rd party lib. It's actually a really clean and enjoyable experience.

<comment><USER27> Huh, didn't think of that. I'll have to try it. Thanks a lot.

</comment></comment></comment></comment><comment><USER28> I believe there is hate because a lot of 'over engineering' was done in most projects. This then necessitated the need for more complicated (and `sometimes` useless) new Java techniques.

This most likely comes from seeing Java (or x,y,z) as thee only tool one would possibly need. Unfortunately, Java much like every other lang should be seen as a tool with pros and cons, in a chest of other tools.

Also, it's bad measure to only consider deployment size regarding any platform effectiveness.

" Let's learn more from Java". I'd rather learn more from "Computer Science" and apply those techniques to Java. Not the other way around.

<comment><USER29> > I believe there is hate because a lot of 'over engineering' was done in most > projects.

Just reading this and thinking: "oh man, if ONLY that was my problem".

</comment></comment><comment><USER30> I've done a ton of Java work, server side and desktop apps. What really amuses me about Java advocates is how they don't realize that the XML is not there for "configuration", it's there to form a dynamic (non-statically typed) appendage to the language. The trick of Spring and similar tools is that under the covers they use the reflection API. It's sort of a joke to claim that you are using static typing, when the config files are more or less a contained bit of dynamic typing.

<comment><USER31> Yeah... A lot of Java apps are really just runtimes for the actual app, which is written in a one-off language wrapped in XML tags.

</comment></comment><comment><USER32> Two other reasons I avoid Java the dependencies ecosystem for a typical Java app is bloated and always changing, and it didn't really live up to the promise of write-once-run-anywhere. And by the way, the over-abstraction habit is really annoying when you're trying to write a simple util app and you can't just say foo = new Foo() instead you have to extra nonsense such as factory = new FooParamsFactory() then fooparams = factory.getFooParams() then then foo = new Foo(fooparams) ... it's nice to get away from that nonsense. I just find Java to the playpen of architecture astronauts who would rather design APIs than write apps.

<comment> St-Clock "it didn't really live up to the promise of write-once-run-anywhere"

Care to explain this one? All the code I have written for the past 10 years do not need to be recompiled and can run on Windows/Linux/Mac/*BSD 32 bit/64 bit. And I used IO, NIO, sockets, threads, files (not necessarily high-level stuff).

<comment><USER33> I have maintained Java apps running on FreeBSD servers, it was a nightmare. And don't even dream of doing that in OpenBSD (which IMHO is the sanest _BSD and even_ nix around).

<comment><USER14> What kinds of problems did you run into?

I've deployed onto primarily Solaris and various flavors of Linux with no problems, but don't have much experience with *BSD... though I've generally assumed it would be a similar experience.

<comment><USER33> Problems like having to patch and build your own Java runtime because (if you are lucky and there is a working one) because Sun made it illegal to distribute modified Java distributions that had not passed the test-kit, and everyone should know that Sun/Oracle do not give access to the test-kit to anyone that doesn't pay them a ton of $$$.

</comment></comment></comment></comment></comment><comment><USER34> I may be the target of this article. I like Ruby quite a bit and I don't like Java at all. The word "hate" isn't quite appropriate, but here's my problem with Java:

I hate how much work Java makes me do to get things done.

It doesn't matter if you're writing "hello world", an English to pig-latin converter, a web server or a lisp interpreter. In every case, it's a lot less code and a lot less work to do in Ruby than it is in Java. Java is just too low-level of a language for anything I'm working on, and in those cases where I _do_ need to get closer to the metal, it's easy enough just to use C.

</comment><comment><USER35> Long live the JVM and here we go again comparing Java to Rails the framework. I've seen the pros and cons of both Java and Ruby. From an organizational standpoint it's hard to beat Java. The performance is there and in a team setting statically typed languages really shine. You can argue about the quality of programmers that flock to Java quoting pg ad nauseaum but we don't live in a lisp world. Elegant code is written by good programmers not the language.

Ruby is fun and really nice for exploring ideas though. It doesn't marry you to an IDE and you can go from idea to reality quite fast with a text editor and a command line. Unfortunately, Rails is a lot of meta-programming magic and syntactic sugar that can really obscure the language for newbies. It's changed the landscape for web frameworks and I would even say mobile as well. RoR didn't invent MVC but it certainly refined our thinking of frameworks in general.

<comment><USER36> > _Elegant code is written by good programmers—not the language._

But some languages make writing elegant code easier than others (compare C to Python, for example).

<comment><USER37> For some task-specific definition of elegance. For me, elegance is not just about how terse the syntax is, but how well it solves the problem at hand and responds to changes around it. For me, some problems require a performant solution as well, and the elegant option is the one that does this without requiring a bunch of rewriting or adding hard to discover dependencies.

I can write some terse AND elegant list comprehension code in Python that takes lines and lines of crappy looping in Java, but I can also write some seriously terse code to centralize business logic via a web service with automatic transaction and security management and have it perform an order of magnitude faster than a similar implementation in Ruby or Python (JEE 6). To me, that is elegant.

Likewise, I can do some elegantly maintainable things with .NET generics that I can't do with Java's lame erasure based implementation.

Of course, you could always just takes Einstein's opinion :) "If you are out to describe the truth, leave elegance to the tailor."

</comment></comment></comment><comment><USER38> I don't hate Java. I just prefer to write code in Ruby.

</comment><comment><USER39> Another reason to stop hating on Java is that in a lot of cities, it would be a fool's errand to assemble another kind of dev team. Like Ruby? Great. Good luck building a team in Omaha.

Skills go where the jobs are: [http://www.indeed.com/jobs?q=ruby&l=Omaha%2C+NE](http://www.indeed.com/jobs?q=ruby&l=Omaha%2C+NE) = 11 jobs [http://www.indeed.com/jobs?q=j2ee&l=Omaha%2C+NE](http://www.indeed.com/jobs?q=j2ee&l=Omaha%2C+NE) = 101 jobs

Bottom line: if you expect to hire developers, in most places, you'll want a language with the deepest bench of talent. The trick is to resist the Java framework nazi's and keep it simple.

<comment><USER40> Unless you have horrable retention issues highering someone who does not know the language your using is not that big of an issue. Taking a C# ASP.NET developer > Ruby on rails is faster than bringing a Java developer who knows nothing about the web into a large Spring/Struts project.

<comment><USER39> That might be true for a basic/early Rails app where it's ok to have script kiddie relationship with Ruby, but if you have a more complex app, I don't think the learning curve is quite as easy as you're making it sound.

My own experience with Rail is that I quickly wanted to see inside and control all of the implicit stuff that was going on, and I needed to invest a lot more time to learn Ruby to have the knowledge that would give the amount of control I wanted.

</comment></comment></comment><comment><USER41> No. I prefer to continue hating Java.

Having recently decided to abandon my anti-Java prejudice from way back I've discovered that everything I hated about Java back in the 90s is still there, only worse.

COBOL at least had the excuse that it was first.

</comment><comment><USER42> Job search in New York City on Dice.com: Java - 2698 Ruby - <USER3>

Even within the Ruby jobs, the majority have a Java requirement within them as well.

Been hearing Ruby aficionados for like a decade, but sorry, it just hasn't penetrated.

<comment><USER17> I think this metric is invalid, the market rarely takes what's best, but rather what's trendy.

Before you begin to troll me, what I'm saying is that >>the metric is not valid<<, not that one language is better than the other.

<comment><USER39> One thing I've learned is that your language/framework is an HR decision.

The jobs metric tells me that if you hope to hire >>experienced<< Ruby programmers, you can probably expect to have fewer to choose from, possibly wait longer, fight harder, and pay more to get them.

I'm not saying you can't hire good programmers and give them a few months to transition, but that wouldn't work for my bootstrapped startup that's planning to ship product in 90 days.

You might say, yeah, but with 2k Java jobs, you have to compete against a lot of employers. Personally, I'd rather take my chances with a deeper pool of Java talent that I can out recruit the competition.

</comment></comment></comment><comment><USER43> This hardly starts to address the things people dislike about Java. Sure, it's a capable language - the JVM even more so. The thing is, it hasn't kept up with the pace of everything else. The JCP is clearly broken.

The best thing for people would be to move on, not in anger but to explore as many languages as possible. Java could very well be the best thing for some BUT you can't really say until you go out and look. From where I'm standing (subjective since I left Java ages ago) most people that go out to explore new things rarely go back.

<comment><USER44> That's an important point.

When Java came out it was a big step forward for a lot of people. Most of the scripting languages with OO features (Ruby, Python, PHP) have a lot of Java influence.

I see the problem is that Java stopped evolving a decade ago. C# shows the kind of path that a Java-like language can follow to get better, and Java just hasn't been moving.

<comment><USER45> Scratch Ruby and Python from your list and I'll agree with you on the OO influence! Not to mention Python is older than Java. I think most of the 'scripting languages' with OO have decidedly not gone the Java/C++ way.

Other than that I'm pretty much in agreement. Even not so long ago as 2002 people would say "Let's use Java" when they really were saying "Let's NOT use C++." C# is a great language, though MS didn't put their heart into really killing Java. I think Microsoft could have dominated with C# outside of Windows World (lots of enterprises still rely on Linux, and Java's not a bad choice for an enterprise app on a Linux server, then there's Android..) if they put more backing behind Mono or just open sourced everything to begin with.

</comment></comment></comment><comment><USER46> I don't hate Java, I just don't want to use it.

I find it ridiculously verbose, and the lack of closures (or even passing around code references) leads to the perceived overengineering mentioned in the post (I'm not sure it's really overengineering all the time - it's just that a rather rigid language forces you to write huge amounts of code to make your library flexible).

That said I have no problem with using programs written in Java - in that case somebody else has already dealt with the things I don't like about Java.

<comment><USER47> It's not overengineering, it's greenspuning[1] around the expressiveness limitations of the langage to make the code flexible.

[1] - <http://en.wikipedia.org/wiki/Greenspuns_Tenth_Rule>

</comment></comment><comment><USER48> What's the general consensus in the HN community regarding GWT? We're pretty happy with it and I think it has a lot of advantages over other frameworks.

<comment><USER24> I can't speak for others, but I hated it. The people I know who liked it were the ones who were scared of JS because they didn't know it very well. The problem with GWT is that if you want to do anything semi-complicated you end up needing to write native JS anyway. So you end up with an ugly cludge of an app written in two different languages and cobbled together with a JNI-like mechanism. I also had a ton of trouble getting their funky debugger to work correctly. Writing in Closure is soooo much nicer. The Closure compiler can give you type safety, which seems to be about the only benefit of GWT.

<comment><USER48> Regarding the debugging features, I think things have gotten a lot better. Debugging is done in Eclipse and you're debugging java, not javascript (if that wasn't clear to some). It honestly works really well. I think there are also quite a few benefits other than type-safety. Easy implementation of asynchronous calls that serialize Java objects is one example.

GWT does have its drawbacks, but we do a lot of complex work in it with very minimal native javascript and support a site with hundreds of thousands of active users.

</comment></comment></comment><comment><USER49> "If you drop static methods, then welcome to Java and its billions of useless factories."

And if you use them everywhere, then welcome to Rails, where to service more than 1 request at a time you actually have to run multiple instances of the whole app behind a balancer.

</comment><comment><USER50> Ruby and Java serve different developer segments, it's much more fun to compare Java and C#. Java and C# are languages that are pretty much the same, serve similar markets but one of which I vastly prefer to program in because of the little niceties: no checked exceptions, first class functions, closures, properties, etc.

Comparing Java to Ruby is a philosophical matter, comparing Java to C# illustrates numerous ways in which the language and runtime (real support for generics) could improve while staying true to its market.

The article honestly looks like a comparison between rails and java rather than ruby and java.

</comment><comment><USER51> I have a question...

The article states:

... Whenever you needed a pluggable system in your code you had to abstract away some concepts in order to make it work. Ruby lets us do it much easier and that's cool. ...

Can someone give a concrete example of this?

</comment><comment><USER52> Java had many problems with absurd over-engineering (aka EJB2) in the past. Even today, a LOT of legacy code is over-engineered and a pain to mantain.

That said, it is possible to write thin apps with Java today, much by the innovations brought by SpringSource. Roo is a rails-like framework to Java that works really well, and the Spring container took out the word EJB from almost every new project.

If I have to choose a language to start a new project today I will probably go with other language, but I have no problems working with Java at all.

<comment><USER23> I have to profess I haven't coded in Java for about 5 years. But when I did, Spring and Hibernate are what drove the final nail in the coffin for me. I'm sure it's changed but after that experience, I never felt the need to revisit.

Kinda like that one girlfriend that messed you up so bad that once you got over everything and realized life was ok, you never felt like rolling by her house ever again. :)

</comment></comment><comment><USER53> I am not in the mood to defend Java, but I would like to give a tip to people who keep mentioning J2EE: J2EE is from a bygone era; learn to say Java EE 6, which is better (although JPA 2 is really the only part I like) and take J2EE out of your vocabularies. Discussing J2EE kind-of makes it sound like your knowledge is out of date.

Also, Scala and Clojure are wonderful languages so I don't understand some of the negative comments about them.

</comment><comment><USER54> C# is a better Java anyway.

<comment><USER38> As far as the language goes, I agree with this but I'd take JVM over CLR anytime.

<comment><USER55> "but I'd take JVM over CLR anytime"

Because of cross-platformity, or is there more?

<comment><USER38> Because it's cross platform, yes. Huge advantage.

</comment></comment></comment></comment><comment><USER56> The part that I don't like is when I can't write a webapp in Java because I don't know about Hibernate and JBoss and Maven and servlets and JDBC and more. I'd love to try a strict language, having used only Clojure and Python lately. Playframework might be an alternative.

<comment><USER19> It doesn't have to be strict. Try a lazy language for a change.

</comment></comment><comment><USER57> Didn't all those "good" things he mentions that come from Java actually come from other languages (Smalltalk, Haskell, Lisp, ...)?

</comment><comment><USER58> I believe the fact that Oracle owns Java is almost reason enough to hate the language.

</comment><comment><USER59> dammit its a tool, whats the big fuss about. People can act so juvenile some times.

<comment><USER60> I'm with you. We all have our preferences. Use whatever tools makes you feel more productive. Ideally all of your code should be language agnostic. An algorithm is an algorithm in any language. While developing programs I've found that coding itself takes the least amount of time, is figuring out the algorithms, overall architecture, and debugging that takes most of the time. The coding part is the easy part.

I do agree that Java has some junk in it, but you don't have to use it. I'm sure I could say the same thing about any language though. I still prefer Java though.

<comment><USER61> It is not easy to avoid the nasty pieces of "factory factory" patterns if the people who you have to work with think it is a great idea. The problem is not peculiar to Java. I spend most of my C# time stepping through OPF (other people's factories) before hitting the code that actually performs some work.

</comment></comment></comment><comment><USER62> > "I always disliked the XML impact on the Java frameworks. It didn't come > from nowhere, though, let's be fair. Java as a languages is not as readable > as Ruby, so it wasn't perfect for configuration. Yaml wasn't popular and > JSON was still not really mature back in 2000. Something had to be chosen > and that was XML. What would you do better back then?"

This piece seems to be mistaking criticism of technology with criticism of people, which is what happens when nerds get too personally attached to languages, frameworks, OSs, etc. I don't think Java folks are stupid for using XML, or anything of the sort. The above succinctly lays out the reasons why that choice made sense at the time, but times change, and that is not a reflection on the judgment of those who made this decision.

</comment><comment><USER63> What I don't understand is, why does this guy care if other people don't like the language he likes? It doesn't change the number of Java jobs or the kind of things you can do with the JVM, so why does he care if a bunch of Rubyists hate Java? Also if he doesn't want people to hate his language, maybe he should use something other than Java.

<comment><USER64> It _does_ change the number of Java jobs.

The more advocacy happens for a technology - often - the more adoption it gets. While not _entirely_ a zero-sum game, a tech choice for a company generally precludes them from seriously using alternatives. If a company switches from Java to Ruby, for example, that's fewer Java jobs, and more Ruby jobs. I'm working with an org doing this right now, and they will then be looking for Ruby devs instead of Java devs. Seems pretty straightforward to me.

Why would the OP using languages other than Java stop people hating Java?</comment></comment>


Show HN: WebGL low-poly saturn example - <AUTHOR> http://whitestormjs.xyz/playground/?example=saturn&dir=demo <comment><USER2> Hey Alex did you do this?

<comment><AUTHOR> Yes, me. What do you want to ask?

<comment><USER2> Its pretty sweet bro, you want to collab on a space game in the future?</comment></comment></comment>


Skin-On Interfaces Welcomes Human-Like Gestures to Control Your Smartphone - <AUTHOR> https://hypebeast.com/2019/10/skin-on-interfaces-smart-artificial-skin-augmented-device-phone-case <comment><USER2> when I first read this I thought it was something like this:[https://futurism.com/glimpse-electronic- tattoos/amp](https://futurism.com/glimpse-electronic-tattoos/amp). I don't see the point of pinching my phone case to do something when I could simply touch the screen to do the same thing.</comment>


Nokia announces mobile store; 70% revenue share to publishers - <AUTHOR> https://publish.ovi.com/

<comment><USER2> No, the revenue share is not 70%:

'Nokia shall pay You seventy percent (70%) of the Net Revenue[...]For purchases made by credit card, "Net Revenue" shall mean the purchase price paid[...]less all applicable taxes[...]. For purchases made via operator billing, "Net Revenue" shall mean the purchase price paid [...] less all applicable taxes[...], charges and fixed aggregate billing charges as determined solely by Nokia.'

"charges and aggregate billing charges" are likely to be a very high percentage as these will ultimately be determined by the greediness of the operators. Plus, apps sold in the EU (where most of the customers are) will undoubtedly be subject to VAT which is over 10%. Normally, a non-European business doesn't have to collect VAT (EU law says we do but you don't have to follow European laws outside of the EU).

That means developers are likely to get less than 70% of 70% of 90%; that is, less than 50% and maybe as low as 33%.

Also note that Nokia hasn't negotiated terms with the operators yet. That isn't a good sign since Nokia hasn't been able to convince AT&T to even carry their phones.

<comment><USER3> Apple already charges sales tax/VAT world-wide so there is no difference here.

The operator deal is very different, yes. Hopefully EU operators are not as stubborn as US operators and Nokia should have bigger influence on them, too.

</comment></comment><comment><AUTHOR> Some more details. From the faq, Store to include applications for both S60(Symbian) and Series 40 devices, including: Java, Flash applications, widgets, ringtones etc.. Store to go live on March 2nd. Supports both pay via credit card and operator billing (discussion on with individual operators)

Source: <https://publish.ovi.com/#FAQ> <http://www.allaboutsymbian.com/live/></comment>


The Anthropologist in an Economist World - <AUTHOR> https://brettscott.substack.com/p/the-anthropologist-in-an-economist <comment><USER2> David's book on money (Debt: The first 5,000 years) is one of the most fascinating I've read. Sad to hear he died.

[0] - [https://en.m.wikipedia.org/wiki/Debt:_The_First_5000_Years](https://en.m.wikipedia.org/wiki/Debt:_The_First_5000_Years)

<comment><USER3> As much as I loved this book when first reading it, it is riddled with errors and a lot of it has been refuted. Not to say it isn't a great read, it is, just take it with a very large grain of salt.

<comment> barry-cotter > Many times throughout the book, Graeber rails against the fact that the > morality of "paying one's debts" functions as a mechanism for keeping > debtors in bondage to creditors. But a few times, Graeber actually reverses > the equation, and laments the power that debtors can sometimes exercise over > creditors, quoting the old saw that "if you owe the bank a hundred thousand > dollars, the bank owns you; if you owe the bank a hundred million dollars, > you own the bank." In other words, whether debt gives power to creditors or > debtors, power is the bad thing, and debt is merely the mechanism by which > power is expressed.

[http://noahpinionblog.blogspot.com/2014/11/book-review- debt-...](http://noahpinionblog.blogspot.com/2014/11/book-review-debt- first-5000-years.html?m=1)

> To start with, he makes several different historical claims, not all of them > compatible:

> (1) Credit transactions preceded and dominated spot transactions in early > human societies.

> (2) Media of account emerged before media of exchange.

> (3) Barter was unknown (or at least extremely rare) WITHIN early human > societies.

> Notice that point (1) is incompatible with either (2) or (3). Early credit > transactions must have involved barter (contradicting number 3) or media of > exchange (contradicting 2). There is no other logical possibility. Yet > because Graeber's peculiar concept of barter excludes a farmer trading a pig > for delivery of an ax in two weeks (to use Murphy's example), his claim that > barter was non-existent tends to become true by definition.

[https://www.econlib.org/archives/2012/07/hummel_on_graeb.htm...](https://www.econlib.org/archives/2012/07/hummel_on_graeb.html)

<comment><USER4> Sure, there are a lot of possibilities that fullfill the three critera - you're imposing the modern conception of credit on early human civilizations.

To put it simply, early credit relationships were dominantly exchanges of services. So it wasn't barter, it's that you would do something for someone with the expectation that they would do something for you.

There, no media of exchange, and no barter. Solved. That's what you get for projecting definitions backwards through time :)

Now for the first time, I'm not sure how that is controversial, if you read that historically debt was a tool of bondage, then it makes perfect sense to frame the power of bondage as a social ill.

</comment></comment></comment></comment><comment><USER4> Rest in Power, David Graeber. Truly a great loss.

</comment><comment><USER5> > As an analogy, imagine a music professor claiming that classical music is > the only form of music, and then proceeding to use Western classical music > notation and scales to transcribe Indian ragas.

It's probably not a coincidence that this video has been viewed 600,000 times in the last 10 days and uses Indian raga as a specific example.

        Music Theory and White Supremacy
        Adam Neely
        https://youtu.be/Kr3quGh7pJA

</comment><comment><USER6> Also, very happy they are using Jitsi for the video at the bottom :).

</comment><comment><USER7> was really upset to hear his passing. he had so many valuable thoughts and ideas

<comment><USER8> I agree. IMO, although I know a significant number of people disagree with me here, I think David Graeber's ideas are important enough that people of all ideological stripes ought to pay attention to what he had to say.

Unfortunately, since he's far, far outside the Overton window, to the left, Americans, by and large, have a rather extreme reaction to those ideas. That's bad, because ideas that make us uncomfortable can sometimes be the ones that allow us to make truly revolutionary leaps in our thinking. Not always -- _e.g._ wanting to make slavery illegal is an idea that ought to make everyone uncomfortable, but has no legitimate place in today's world. But, definitely sometimes, and I believe Graeber's ideas are the type that could take us forward, rather than backward.

<comment><USER9> > Not always -- e.g. wanting to make slavery illegal is an idea that ought to > make everyone uncomfortable, but has no legitimate place in today's world.

I had a hard time parsing this. Did you mean _legal_?

<comment><USER8> Yes. Autocorrect strikes again.</comment></comment></comment></comment>


Digitalisation vs. Automation Is about Capabilities - <AUTHOR> https://blog.georgovassilis.com/2019/07/21/digitalisation-vs-automation-it-is-about-capabilities/ <comment><AUTHOR> "Digitalisation is the last transformation stage of a manual process which leads to the process dissolving and being replaced by one or more organisational capabilities."</comment>


Create Cards via Email - <AUTHOR> http://blog.trello.com/create-cards-via-email/

<comment><USER3> I think its great that this was an intern's project at Trello and he got to announce it himself on their blog. Nice to see how much ownership they give their developers and sounds like a great internship.

</comment><comment><USER4> Haha, I didn't realize this was a new feature. I googled this and found this feature, and was using this feature yesterday. (info was on their Support site, but not their blog) I missed my chance for sweet karma! :-)

</comment><comment><USER5> I love trello but I still don't understand why I can't create more than 6 labels and assign my own custom colors to each label.

I don't understand why I can't remove a label from the board and have that label be removed from cards throughout the board.

I don't understand why I can't change the label's color instead of changing the color's label (if that makes any sense).

It _seems_ easy - can anybody elaborate as to why this might be more difficult than it seems?

<comment><USER6> My instinct is that labels are an afterthought, and that if you're trying to do too much with labels, you're looking for more complexity than Trello wants to give you.

</comment></comment><comment><USER7> This is great, the next feature I'd love to see would be a way to update existing cards via email. The use case: I create a card by forwarding an email to my trello email address. In the meantime, the email thread continues and I have a few more updates on it. Now I want to update the Trello card with the updates from that email thread. If I just forward that email to Trello, it is now creating another new card instead of updating the existing card. Would others find this feature as useful as I would?

</comment><comment><USER8> A great feature. We used Trello to plan our trip, but found it a bit cumbersome as a checklist of checklists (which is what we really wanted - <USER2> like Progect [1]). We had to print out all the tasks on paper, and use it as a real checklist - usable but a bit clunky.

[1] [http://progect-manager.en.softonic.com/palm](http://progect- manager.en.softonic.com/palm)

</comment><comment><USER9> I was able to do this via Zapier, but never found a solid use case for this. Do love Trello though.

</comment><comment><USER10> Can anyone here point me to a library/framework that would allow for monitoring incoming emails (similar to this scenario) and take actions based on email address it was sent to?

<comment><USER11> There are quite a few ways you can accomplish this with Linux + Postfix (other MTAs too) but since you have specific email addresses you want to process mail for as in this scenario the quickest way would be to have an alias[1] pipe to it to your script (language agnostic in this case). You can even use a .forward file, which might even work in the case of shared hosting.

A quick example of this for Perl is [http://www.perlmonks.org/?node_id=1030830](http://www.perlmonks.org/?node_id=1030830) (replace the perl script with any program)

Another way would be to setup a transport map that targets a hook that you setup in your master.cf file but it's probably best to find more tutorials online to understand everything that is taking place.

1\. If your domain is using a virtual alias then point the virtual domain's recipient to the alias.

<comment><USER10> You guys are great. Since we are building a SaaS product using a service is a good option to get us going but eventually we want to have this function in- house. I will check out all the pointers here (both service + custom solution). Thanks a lot!

</comment></comment></comment><comment><USER12> They have done an amazing job with this. You can assign cards to people and even label cards through email. Sweet!</comment>


Ask HN: What to ask for when entering as co-founder - <AUTHOR> Hi all,
I've been working with a SaaS company for the past few weeks to test our compatibility as co-founders. The company has raised 1M so far but burned all of it over the last 3.5 years..They have now pivoted (hence the understanding that they need a new co founder). There are currently 2 co-founders and 3 employees.
I was offered 5% from the ESOP and a minimum wage salary (as the company will be dead soon without an additional investment), with 4 years of vesting and a 1 year cliff. There might also be a future ICO where I will be getting 1.3% of the tokens.
Each of the founders holds 25% of the company.
I was thinking that a 5:1 ratio is not a good deal for me, especially as I am risking a lot entering into unclear waters and my contribution is significant.
Any thoughts you might have about how to negotiate and what is important to ask would be great. I'll just mention that I was hoping to get 10%-11%.
Thanks! <comment><USER2> 5-10% is common in my experience for an early employee with a "co-founder" title at company at this stage. Critically, they already raised money, so you are not taking as much risk as the founders. You are an employee, and a founder in title only.

That said, my approach would be to offer them two options. Either they give you 5% with a market rate (100k+) salary, or they give you 15% with the shit salary. They can't afford to pay you market rate, so they'll choose the shit salary, but likely bring you down to 11%.

It all comes down to what you're worth to them. If they're screwed without you, and you are prepared to walk away, then you'll get the terms you want.

Keep in mind that 5%, or 15% or even 90% will likely be worth nothing ever. Money now is good. The pivot is a bad sign. If they can't afford to pay you beyond a shit salary, that's a bad sign too. It sounds like the founders have no direction and just want to coast along until their VC money dries up.

<comment><AUTHOR> You're right, though it got me thinking about what is the actual offer... If they are offering 5% this might mean much less. After the 1m round, there is an expected dilution of 25%. Additionaly, the ESOP will have to be refilled (since I will be getting most of it) which will dilute with another 10%... My current estimate is that if N is what they are offering me than the real offering is expressed by N _(1-N)_ 0.75. So if they are offering 5% this actually means 3.5%. Im wondering if they take this into consideration when they say "fully diluted".

</comment></comment><comment><USER3> How much is 5% of a company that is likely to be dead soon worth to you? After the pivot, all the work lies ahead. With a $1 million investment, you probably want to see the cap table if the 5% of a company likely to be dead is worth enough to proceed.

A few years ago, I made this: [http://fumoney.kludgecode.com/default.aspx](http://fumoney.kludgecode.com/default.aspx) The caveat I would add now is a discount factor based on an assessment of a liquidity event. There are lots of high value startups that are not going with an IPO or any other event that allows employees to cash out. Manually adjusting the calculation can be done by multiplying the FU money field by 1.0/probabilityOfSuccessfulExist. Example multiply by 10 if the probability of the exit amount is 10%.

Good luck.

</comment><comment><USER4> tl;dr - It sounds to me like you're being taken for a ride.

From what you've said, it sounds like:

1) The company has no tangible or intangible assets (no money, no viable product, no significant physical assets, no distinctive IP).

2) The company has existing liabilities (existing full time employment contracts that would have a cost to exit, maybe some rental agreements too).

3) Passive shareholders hold ~35% of the equity.

4) Two employees hold 50% of the equity, without any vesting conditions.

These conditions sound like you're starting a company from scratch, except with some extra weight on your back. There are some problems with what's been proposed to you:

\- ESOP rather than shares: usual things to watch out for with ESOP: what is the strike price, what is the vesting period etc. I've seen offers that included stock options which would mean _negative_ cash flow for the employee (i.e. cost to exercise the options over 4 years is more than the salary over 4 years).

\- Even if they gave you shares instead of options, they're offering you a smaller cut (5% instead of 25%) AND their shares aren't subject to vesting but yours are!

Perhaps there are details I've missed or that I've guessed incorrectly.

But if someone offered me something like this, then I'd make a reasonable counter-offer (worked out from scratch from the objective facts, _not_ based at all on their offer). If they were to act shocked or otherwise indicate my counter-offer is far off what they would be willing to agree to, I'd shake hands and walk away.

</comment><comment><USER5> If they need a new cofounder after 3.5 years, then to me is sounds like they failed and need to start over. If so, then aren't you really on the same footing as the original cofounders and deserve the be on par with them? If not, are you really a cofounder or just a valuable hire.

I understand the there has already been dilution so you're not starting from a clean slate. But there is nothing preventing them from reassigning some of their stock to you.

<comment><AUTHOR> "But there is nothing preventing them from reassigning some of their stock to you"

This will actually result in a tax event valued at the company's value no? This is the reason they offered ESOP in their claim.

<comment><USER5> That's a good point. Though if they need a new founder rather than a key employee, there maybe an argument that the shares current value is close to 0.</comment></comment></comment>


A command launcher for Chrome and Firefox - <AUTHOR> https://oksteward.com/ <comment><USER2> On the main page: "evoke" should be "invoke".

This reminds me of the old Ubiquity addon for Firefox. Was that an inspiration or is this something different?

<comment><AUTHOR> Thanks, I will correct it soon. This extension was inspired by Alfred on MacOS.I vaguely heard about Ubiquity addon, but I haven't used it.</comment></comment>