Accidentally destroyed production database on first day of a job - <AUTHOR> https://np.reddit.com/r/cscareerquestions/comments/6ez8ag/accidentally_destroyed_production_database_on/ <comment><USER2> Sorry, but if a junior dev can blow away your prod database by running a script on his _local_ dev environment while following your documentation, you have no one to blame but yourself. Why is your prod database even reachable from his local env? What does the rest of your security look like? Swiss cheese I bet.

The CTO further demonstrates his ineptitude by firing the junior dev. Apparently he never heard the famous IBM story, and will surely live to repeat his mistakes:

 _After an employee made a mistake that cost the company $10 million, he walked into the office of Tom Watson, the C.E.O., expecting to get fired. "Fire you?" Mr. Watson asked. "I just spent $10 million educating you."_

<comment><USER2> Here's some simple practical tips you can use to prevent this and other Oh Shit Moments(tm):

\- Unless you have full time DBAs, do use a managed db like RDS, so you don't have to worry about whether you've setup the backups correctly. Saving a few bucks here is incredibly shortsighted, your database is probably the most valuable asset you have. RDS allows point-in-time restore of your DB instance to any second during your retention period, up to the last five minutes. That will make you sleep better at night.

\- Separate your prod and dev AWS accounts entirely. It doesn't cost you anything (in fact, you get 2x the AWS free tier benefit, score!), and it's also a big help in monitoring your cloud spend later on. Everyone, including the junior dev, should have full access to the dev environment. Fewer people should have prod access (everything devs may need for day-to-day work like logs should be streamed to some other accessible system, like Splunk or Loggly). Assuming a prod context should always require an additional step for those with access, and the separate AWS account provides that bit of friction.

\- The prod RDS security group should only allow traffic from white listed security groups also in the prod environment. For those really requiring a connection to the prod DB, it is therefore always a two-step process: local -> prod host -> prod db. But carefully consider why are you even doing this in the first place? If you find yourself doing this often, perhaps you need more internal tooling (like an admin interface, again behind a whitelisting SG).

\- Use a discovery service for the prod resources. One of the simplest methods is just to setup a Route 53 Private Hosted Zone in the prod account, which takes about a minute. Create an alias entry like "db.prod.private" pointing to the RDS and use that in all configurations. Except for the Route 53 record, the actual address for your DB should not appear anywhere. Even if everything else goes sideways, you've assumed a prod context locally by mistake and you run some tool that is pointed to the prod config, the address doesn't resolve in a local context.

<comment><USER3> Would you recommend all these steps even for a single-person freelance job? Or is it overkill?

<comment><USER4> Depends. Do you make mistakes?

I absolutely do. "Wrong terminal", "Wrong database", etc. mistakes are very easy to make in certain contexts.

The trick is to find circuit-breakers that work for you. Some of the above is probably overkill for one-person shops. You want some sort of safeguard at the same points, but not necessarily the same type.

This doesn't really do it for me, but one person I know uses iTerm configured to change terminal colors depending on machine, EUID, etc. as a way of avoiding mistakes. That works for him. I do tend to place heavier-weight restrictions, because they usually overlap with security and I'm a bit paranoid by nature and prefer explicit rules for these things to looser setups. Also, I don't use RDS.

I'd recommend looking at what sort of mistakes you've made in the past and how to adjust your workflow to add circuit breakers where needed. Then, if you need to, supplement that.

Except for the advice about backups and PITR. Do that. Also, if you're not, use version control for non-DB assets and config!

<comment><USER5> For windows servers I use a different colored background for more important servers.

<comment><USER6> I do this with bash prompt colors on all our servers. Prod is always red.

</comment></comment></comment></comment></comment></comment><comment><USER7> I was on a production DB once, and ran SHOW FULL PROCESSLIST, and saw "delete from events" had been running for 4 seconds. I killed the query, and set up that processlist command to run ever 2 seconds. Sure enough, the delete kept reappearing shortly after I killed it. I wasn't on a laptop, but I knew the culprit was somewhere on my floor of the building, so I grabbed our HR woman who was walking by and told her to watch the query window, and if she saw delete, I showed her how to kill the process. Then I ran out and searched office to office until I found the culprit -

Our CTO thought he was on his local dev box, and was frustrated that "something" was keeping him from clearing out his testing DB.

Did I get a medal for that? No. Nobody wanted to talk about it ever again.

<comment><USER8> Actually, the CTO should have mailed the dev team saying:

        Hi,

        Yesterday, I thought I was on my local machine and clear the database, while I was in fact on the production server.
        Luckily knodi123 caught it and killed the delete process. This is a reminder that *anybody* can make mistakes,
        so I want to set up some process to make sure this can't happen, but meanwhile I would like to thank knodil123.

       Best,

       CTO

</comment></comment><comment><USER9> My comment I left there:

Lots of folks here are saying they should have fired the CTO or the DBA or the person who wrote the doc instead of the new dev. Let me offer a counter point. Not that it will happen here ;)

They should have run a post mortem. The idea behind it should be to understand the processes that led to a situation where this incident could happen. Gather stories, understand how things came to be.

With this information, folks can then address the issues. Maybe it shows that there is a serially incompetent individual who needs to be let go. Or maybe it shows a house of cards with each card placement making sense at the time and it is time for new, better processes and an audit of other systems.

The point being is that this is a massive learning opportunity for all those involved. The dev should not have been fired. The CTO should not have lost his shit. The DB should have regularly tested back ups. Permissions and access needs to be updated. Docs should be updated to not have sensitive information. The dev does need to contact the company to arrange surrender of the laptop. The dev should document everything just in case. The dev should have a beer with friends and relax for the weekend and get back on the job hunt next week. Later, laugh and tell of the time you destroyed prod on your first day (and what you learned from it).

<comment><USER10> The firing order, in theoretical order for preventing future problems:

1\. CTO As the one in charge of the tech, allows loss of critical data. If anyone should be fired, it's the cto. And firing this guy apparently will have the greatest positive impact to the company. Assuming they can hire a better one. I think given how stupid this cto is, that should be straightforward.

2\. The executives who hired the cto. People hire people similar to themselves, it seems the executives team are clueless about what kind of skills a cto should have. These people will continue fail the dev team by hiring incompetent people, or force them to work in a way that causes problem.

3\. Senior devs in the team. Obviously these people did not test what they wrote. If anyone had ever dryrun the training doc, they should prevent the catastrophe. It's a must do in today's dev environment. The normal standard is to write automatic tests for every thing though.

This junior dev is the only one who should not be fired...

<comment><USER11> I'm amazed at how quickly everyone is trying to allocate blame, as if there _must_ be someone upon whom to heap it all on. Commenters on both Reddit and HN are being high and mighty, offering wisdom that _they_ would never have allowed this to take place, while eager to point fingers. I bet far more than half of these commenters have at one time or another worked for at least one company that had this kind of setup, and didn't immediately refuse to work on other tasks until the setup was patched. Hypocrites.

The fact is, this kind of scenario is extremely common. Most companies I have worked for have the production database accessible from the office. It's a very obvious "no no", but it's typical to see this at small to medium sized companies. The focus is on rushing every new feature under the sun, and infrastructure is only looked at if something blows up.

 _Nobody_ should have been fired. Not the developer, not the senior devs, not the sysadmins, and not the CTO. This should have been nothing more than a wake-up call to improve the infrastructure. That's it. The only blame here lies with the CTO - not for the event having taken place, but only because their immediate reaction was to throw the developer under the bus. A decent CTO would have simply said "oh shit guys, this can't happen again. please fix it". If the other executives can't understand that sometimes shit happens, and that a hammer doesn't need to be dropped on _anyone_ , then they're not qualified to be running a business.

<comment><USER10> Well you need to consider the cto's reaction.

His reaction shows that he is the no1 to fire, and has a good reason.

What you said is true, but does not matter. The cto already show that he is clueless...

</comment></comment></comment></comment><comment><USER12> > _" i instead for whatever reason used the values the document had."_

>They put full access plaintext credentials for their production database in their _tutorial documentation_

WHAT THE HELL. _Wow_. I'd be shocked at that sort of thing being written out in a non-secure setting, like, anywhere, at all, never mind in freaking documentation. Making sure examples in documentation are never real and will hard fail if anyone tries to use them directly is not some new idea, heck there's an entire IETF RFC (#2606) devoted to reserving TLDs specifically for testing and example usage. Just mind blowing, and yeah there are plenty of WTFs there that have already been commented on in terms of backups, general authentication, etc. But even above all that, if those credentials had full access then "merely" having their entire db deleted might even have been a good case scenario vs having the entire thing stolen which seems quite likely if their auth is nothing more then a name/pass and they're letting credentials float around like that.

It's a real bummer this guy had such an utterly awful first day on a first job, particularly since he said he engaged in a huge move and sunk quite a bit of personal capital from the sound of it in taking that job. At the same time that sounds like a pretty shocking place to work and it might have taught a ton of bad habits. I don't think it's salvageable but I'm not even sure he should try, they likely had every right to fire him but threatening him at all with "legal" for that is very unprofessional and dickish. I hope he'll be able to bounce back and actually end up in a much better position a decade down the line, having some unusually strong caution and extra care baked into him at a very junior level.

<comment><USER13> There's also a high chance that document was shared on Slack. In which case, they were one Slack breach away from the entire world having write access to their prod database.

It's depressing how many companies blindly throw unencrypted credentials around like this.

<comment><USER14> Tell me about it. Fortunately where I work is sane and reasonable about it.

We have a password sheet. You have to be on the VPN(login/password). Then you can log in. Login/Password(diff from above)/2nd password+OTP. Then a password sheet password.

I'm still rooting out passwords from our repo with goobers putting creds in sourcecode (yeah, not config files....grrrrr). But I attack them as I find them. Ive only found 1 root password for a DB in there... and thankfully changed!

<comment><USER15> A plaintext password sheet? Despite the layers of network access control, this is a horribly bad practice in our modern age. Vault is free and encrypted secret storage systems are hardly a new concept.

<comment><USER14> Not at all. The password sheet password is actually a GPG key. Everything stored encrypted.

We suffer from NIH greatly. We end rolling our own stuff because either we don't trust 3rd party stuff, or it doesn't work in our infrastructure. In this case, multiple access locks with GPG is sufficient.

<comment><USER15> A response 8 days later is better than no response at all, right? :)

I agree that a multi-recipient GPG protected file is sufficient for a small org. In fact, that's how I used to do it Circa 2011. We found it worked quite well - we committed the GPG protected files to a version control system (git) and used githooks to make sure that only encrypted files were permitted, preventing users from intentionally/accidentally defeating gitignore.

</comment></comment></comment></comment></comment></comment><comment><USER16> Plot twist: CTO or senior staff needed to cover something up (maybe a previous loss of critical business data) and arranged for this travesty to likely happen permitted sufficient number of junior devs went through "local db setup guide" mockery of a doc.

Either that or this is a "Worst fuckup on the first day on job" fantasy piece - I refuse to acknowledge living in the world where alternatives have any meaningful non-zero probability of occurring.

<comment><USER17> There are no upper bounds on incompetence. I've seen enough WTFs even in companies that didn't seem particularly dysfunctional, and that had some very competent people.

And then it takes only one shitty manager, or manager in a bad mood, to get the innocent junior dev fired.

</comment></comment><comment><USER18> People will screw up, so you have to do simple things to make screwing up hard. The production credentials should never have been in the document. Letting a junior have prod level access is not that far out of the normal in a small startup environment, but don't make them part of the setup guide. Sounds like they also have backup issues, which points to overall poor devops knowledge.

Not part of this story, but another pet peeve of mine is when I see scripts checking strings like "if env = 'test' else <runs against prod>". This sets up another WTF situation if someone typos 'test' now the script hits prod.

<comment><USER19> Heh, or take a Netflix Chaos Monkey approach and have a new employee attempt to take down the whole system on their first day and fire any engineers who built whatever the new employee is actually able to break!

<comment><USER20> Why fire them? It's valuable experience that you are paying a lot for them to gain. Better: hold a postmortem, figure out what broke, and make the people who screwed it up originally fix it. Keep people who screw things up, as long as they also fix it.

<comment><USER19> I wasnt serious about "firing" \-- but was just maintaining the spirit of what happened to the OP on reddit...

but yeah - I agree with you...

</comment></comment></comment></comment><comment><USER21> Yeah, another case of "blame the person" instead of "blame the lack of systems". A while back, there was a thread here on how Amazon handled their s3 outage, caused by a devops typo. They didn't blame the DevOp guy, and instead beefed up their tooling.

I wonder whether that single difference - blame the person vs fix the system/tools predicts the failure or success of an enterprise?

<comment><USER22> The Amazon DevOp guy was fired for that mistake, just FYI.

<comment><USER23> Have any proof of this?

<comment><USER24> Why do you all act like one party needs proof, but only because they are refuting what was said originally, also, without proof.

Neither is providing proof, so asking one party for proof and not the other is obviously absurd.

<comment><USER25> In the absence of proof one way or the other, people believe what seems more reasonable to them. Not particularly absurd at all.

</comment></comment></comment></comment></comment><comment><USER26> Assuming the details are correct, this should be considered a win by the junior dev. It only took a day to realize that this is a company he really, really doesn't want to try to learn his profession at.

<comment><USER26> He should get that laptop back to them IMMEDIATELY. These sound like exactly the sort of douches would try to charge him with theft. (Edit: Why is it not surprising they don't have a protocol in place for managing dismissing staff and, like, getting their stuff back?)

<comment><USER27> Well, the customers database with important data just got nuked, so even if there is protocol, people who would normally do the steps have different things in mind. Laptop and such is least of their concerns.

</comment></comment></comment><comment><USER28> > The CTO told me to leave and never come back. _He also informed me that > apparently legal would need to get involved due to severity of the data > loss_.

I don't know if I should laugh or cry here.

</comment><comment><USER29> Guaranteed the CTO is busily rewriting the developer quide and excising all production DB credentials from the docs so that he can pretend they were never there. While the new guy's mistake was unfortunate in a very small way, the errors made by the CTO and his team were unfortunate in a very big way. The vague threat of legal action is laughable, and the reaction of firing the junior dev who stumbled into their swamp of incompetency on his first day speaks volumes about the quality or the organization and the people who run it. My advice... learn something from the mistake, but otherwise walk away from that joint and never look back. It was a lucky thing that you found out what a mess they are on day 1.

</comment><comment><USER30> Several years back I worked as a DBA at a managed database services company, and something very similar happened to one of our customers who ran a fairly successful startup. When we first onboarded them I _strongly_ recommended that the first thing we do is get their DB backups happening on a fixed schedule, rather than an ad-hoc basis, as their last backup was several months old. The CEO shuts me down, and instead insists that we focus on finding a subtle bug (you can't nest transactions in MySQL) in one of their massive stored procedures.

It turns out their production and QA database instances shared the same credentials, and one day somebody pointed a script that initializes the QA instances (truncate all tables, insert some dummy data) at the production master. Those TRUNCATE TABLE statements replicated to all their DB replicas, and within a few minutes their entire production DB cluster was completely hosed.

Their data thankfully still existed inside the InnoDB files on disk, but all the organizational metadata data was gone. I spent a week of 12 hour days working with folks from Percona to recover the data from the ibdata files. The old backup was of no use to us since it was several months old, but it was helpful in that it provided us a mapping of the old table names to their InnoDB tablespace ids, a mapping destroyed by the TRUNCATE TABLE statements.

</comment><comment><USER31> No disrespect to the OP but this sounds pretty fake. If the database in question was important enough to fire _someone immediately_ over then there wouldn't have been the creds floating around on an onboarding pdf. And involving legal? Has anyone here heard of anything similar? I'm just 1 datapoint but I know I haven't.

<comment><USER32> Yeah, I thought it sounded fake as well. I mean things like this happen, but something about the story just doesn't ring true to me.

</comment></comment><comment><USER33> plot twist: dev will learn Monday this is a initialization joke and the whole company is laughing of all the threads he or she starts here and on reddit.

<comment><USER34> plot twist: the dev attempts to off himself, and the company stops "laughing off".

<comment><USER35> plot twist: the dev is restored from backups

<comment><USER36> plot twist: but the backups are 6 months out of date, so the dev has no recollection of the incident

<comment><USER31> Plot twist: the developer was working at Reddit

</comment></comment></comment></comment></comment><comment><USER37> It's not the CTO's fault. It's the document's fault! We should never have documentation again, this is what it has done to us! We need to revert to tribal knowledge to protect ourselves. If we didn't document these values, people wouldn't be pasting them in places they shouldn't be!

/s

</comment><comment><USER38> For some years now I've stopped bothering with database passwords. If technically required I just make them the same as the username (or the database name, or all three the same if possible). Why? Because the security offered by such passwords is invariably a fiction in practice, I've never seen an org where they couldn't be dug out of docs or a wiki or test code. Instead database access should be enforced by network architecture: the production database can only be accessed by the production applications, running in the production LAN/VPC. With this setup no amount of accidental (or malicious) commands run by anyone from their local machine (or any other non production environment) could possibly damage the production data.

</comment><comment><USER3> Side question, as a dev with zero previous ops experience, now the solo techie for a small company and learning ops on the fly, we're obviously in the situation where "all devs have direct, easy access to prod", since I'm the only dev. What steps should I take before bringing on a junior dev?

<comment><USER14> Do as best as you can to "find compute room" (laptop, desktop, spare servers on rack that arent being used, .. cloud) , and make a Stage.

Make changes to Stage after doing a "Change Management" process (effectively, document every change you plan to do, so that a average person typing them out would succeed). Test these changes. It's nicer if you have a test suite, but you won't at first.

Once testing is done and considered good, then make changes in accordance to the CM on prod. Make sure everything has a back-out procedure, even if it is "Drive to get backups, and restore". But most of these should be, "Copy config to /root/configs/$service/$date , then proceed to edit the live config". Backing out would entail in restoring the backed-up config.

________________________

Edit: As an addendum, many places too small usually have insufficient, non- existent, or schrodinger-backups. Having a healthy living stage environment does 2 things:

1\. You can stage changes so you don't get caught with your pants down on prod, and

2\. It is a hot-swap for prod in the case Prod catches fire.

In all likelihood, "All" of prod wouldn't DIAF, but maybe a machine that houses the DB has power issues with their PSU's and fries the motherboard. You at least have a hot machine, even if it's stale data from yesterday's imported snapshot.

<comment><USER39> You missed one of the really nice points of having a stage there. You use it to test your backups by restoring from live every night/week. By doing that, you discourage developing on staging and you know for sure you have working backups!

<comment><USER14> Indeed. But if it's just 1 guy who's the dev, I was trying to go for something that was rigorous, still yet very maintainable.

Ideally, you want test->stage->prod , with puppet and ansible running on a VM fabric. Changes are made to stage and prod areas of puppet, with configuration management being backed by GIT or SVN or whatever for version control. Puppet manifests can be made and submitted to version control, with a guarantee that if you can code it, you know what you're doing. Ansible's there to run one-off commands, like reloading puppet (default is checkins every 30min)

And to be even more safe, you have hot backups in prod. Anything that runs in a critical environment can have hot backups or otherwise use HAproxy. For small instances, even things like DRBD can be a great help. Even MySQL, Postgres, Mongo and friends all support master/slave or sharding.

Generally, get more machines running the production dataset and tools, so if shit goes down, you have: machines ready to handle load, backup machines able to handle some load, full data backups onsite, and full data backups offsite. And the real ideal is that the data is available on 2 or 3 cloud compute platforms, so absolute worst case scenario occurs and you can spin up VM's on AWS or GCE or Azure.

\--Our solution for Mongo is ridiculous, but the best for backing up. The Mongo backup util doesn't guarantee any sort of consistency, so either you lock the whole DB (!) or you have the DB change underneath you while you back it up... So we do LVM snapshots on the filesystem layer and back _those_ up. It's ridiculous that Mongo doesnt have this kind of transactional backup appratus. But we needed time-series data storage. And mongodb was pretty much it.

</comment></comment></comment></comment><comment><USER40> The author should get their own legal in line - does the contract even allow termination on the spot. If not, the employer is just adding to their own pile of ridiculous mistakes.

<comment> FLUX-YOU Probably. At will employment is pretty common in the US.

<comment><USER33> land of the uninsured, non unionized free

<comment><USER34> When America was more deservingly called the "land of the free" in the 40s and 50s, they were also heavily unionized.

(Well, then it was "land of the free, blacks excepted")

</comment></comment></comment></comment><comment><USER41> The ending with taking the laptop to home though... He is a modern time Dostoevsky.

</comment><comment><USER42> One of the questions I asked my manager during the interview process was how did he feel about mistakes?

I knew I was being brought in to rearchitect the entire development process for an IT department and that I would make architectural mistakes no matter how careful I was and that I would probably make mistakes that would have to be explained to CxOs.

Whatever the answer he gave me, I remember being satisfied with it.

</comment><comment> rsc-dev [https://github.com/search?utf8=%E2%9C%93&q=database+password...](https://github.com/search?utf8=%E2%9C%93&q=database+password&type=Commits)

</comment><comment><USER43> Reminds me of my first dev job, when I got a call during lunch:

"The server has been down all day, and you are the only one who hasn't noticed. What did you break?"

"Well, I saw that all the files were moved to `/var/www/`, and figured it was on purpose."

Suffice it to say, I got that business to go from Filezilla as root to BitBucket with git and some update scripts.

</comment><comment><USER44> Something tells me their production password was nothing like a 20-char random string...

</comment><comment><USER35> I am the only one who is surprised that he can get the keys to the kingdom on day 1?

Day 1 is when you setup your desk and get your login. Then go back to HR to do the last hiring paperwork.

It should take a good week before a new employee is able to fuck up anything. Really.

<comment><USER45> How long do you want to adjust the height of your chair? Setting up the dev enviroment often takes ages. Why wouldn't it be the first thing to do? There will be enough progress bars while updating something like visual studio to finde time to re-adjust the chair.

</comment></comment><comment><USER46> Hilarious. I wonder if it's true.

<comment><USER47> This happened to a friend at a new job a few weeks ago. He wasn't fired, though.

<comment><USER44> If the bit about no working backups is also true, he's likely to need a new job anyway. :)

</comment></comment></comment><comment><USER48> I did the same thing early on in my career. Shut down several major ski- resorts in Sweden for an entire day during booking season by doing what we always did, running untested code in production to put out fires. Luckily, my company and our customers took that as a cue to tighten up the procedures instead of finding someone to blame. I hear this is how it works in aviation as well, no one gets blamed for mistakes since that only prevents them from being dealt with properly. Most of us are humans, humans make mistakes. The goal is to minimize the risk for mistakes.

</comment><comment><USER49> I stopped believing reddit posts a long time ago

<comment><USER50> Exactly, the post is very clichéd. I have about 75% belief that it's fictional. I guess it could be sort of entertaining to see how easy it is to get a few hundred software engineers on reddit and hacker news worked up into a sympathetic and self-righteous frenzy with a simple and entirely fictional paragraph posted for free from a throwaway account.

<comment><USER51> I am about 101% it's fake. "Unfortunately apparently those values were actually for the production database (why they are documented in the dev setup guide i have no idea)" \- yeah, no. Had you told me you were able to screw the production db up because it had no su password set, you might have got me. But this is bullshit.

</comment></comment></comment><comment><USER52> Technical infrastructure is often the ultimate in hostile work environments. Every edge is sharp, and great fire-breathing dragons hide in the most innocuous of places. If it's your shop, then you are going to have a basic understanding of the safety pitfalls, but you're going to have no clue as to the true severity of the situation.

If you introduce a junior dev into this environment, then it's him that is going to discover those pitfalls, in the most catastrophic ways possible. But even experienced developers can blunder into pitfalls. At least twice I've accidentally deployed to production, or otherwise ran a powerful command intended to be used in a development environment on production.

Each time, I carefully analyze the steps that led up to running that command and implemented safety checks to keep that from happening again. I put all of my configuration into a single environment file so I see with a glance the state of my shop. I make little tweaks to the project all the time to maintain this, which can be difficult because the three devs on the project work in slightly different ways and the codebase has to be able to accommodate all of us.

While this is all well and good, my project has a positively decadent level of funding. I can lavish all the time I want in making my shop nice and pretty and safe.

A growing business concern can _not_ afford to hire junior devs fresh out of code school / college. That's the real problem here. Not the CTO's incompetence, any new-ish CTO in a startup is going to be incompetent.

The startup simply hired too fast.

<comment><USER27> The same thing could happen to senior. In particular, to tired overworked senior. It is more likely to happen to junior, because junior is likely to be overwhelmed. However, mistakes like this happen to prole of all ages and experience levels.

Seniority is what makes you not put the damm password into set up document. That was the inexperienced level of mistake. Forgotting to replace it while you are seting up day one machine is mistake that can happen to anyone.

<comment><USER52> True, but a senior engineer, even if he is never able to make architecture decisions, can still be held accountable for knowing better. That is precisely why they are paying him the big bucks.

If a shop is being held together with duct tape and elbow grease, then you should have known that going in, and developed personal habits to avoid this sort of thing. Being overworked and tired isn't an excuse. Sure, the company and investors have to bear the real consequences, but you as an IC can't disclaim responsibility.

</comment></comment></comment><comment><USER53> This company has a completely different problem: no separation of duties. Start with talking to the CTO how this could have happened in the first place, re-hire the junior dev.

After all, if the junior dev could do it, so can everybody else (and whoever manages to get their account credentials).

</comment><comment><USER54> When it comes to backup, there are two types of people, ones who do backup and ones who will do backup.

</comment><comment><USER55> This is purely the fault of the entire leadership stack.

From Sr dev/lead dev, dev manager, architect, ops stack, all the directors, A/S/VPs, and finally the CTO. You could even blame the CEO for not knowing how to manage or qualify a CTO. Even more embarrassing is if your company is a tech company.

I think a proper due diligence would find the fault in the existing company.

It is not secure to give production access and passwords to a junior dev. And if you do, you put controls in place. I think if there is insurance in place some of the requirements would have to be reasonable access controls.

This company might find itself sued by customers for their prior and obviously premeditated negligence from lack of access controls (the doc, the fact they told you 'how' to handle the doc).

<comment><USER56> The Junior dev does bear a small amount of blame, if you really want to go the blameful route.

But figuring out who to blame is toxic. You've got to go for a blameless culture and instead focus on post mortems and following new and better processes.

Things can absolutely always go to shit no matter where you work or how stupidly they went to shit. What differentiates good companies from bad ones is whether they try to maximize the learning from the incident or not.

</comment></comment><comment><USER57> Ahhhhh haaaa yeah.....I've done that.

It was the second day, and I only wiped out a column from a table, but it was enough to bring business for several hundred people down for a few hours. It was embarrassing all round really. Live and learn though - at least I didn't get fired!

</comment><comment><USER58> Obviously this is mostly CTO's screw up.

But the junior dev is not fully innocent either: he should have been careful about following instructions.

For extra points (to prove that he is a good developer) - he should have caught that screw up with username/passwords in the instruction. Here's approximate line of reasoning:

\---

What is that username in the instruction responsible for? For production environment? Then what would happen if I actually run my setup script in production environment? Production database would be wiped? Shouldn't we update setup instruction and some other practices in order to make sure it would not happen by accident?).

\---

But he it is very unlikely that this junior dev would be legally responsible for the screw up.

</comment><comment><USER59> I destroyed an accounting database at a company during a high school summer job.

A mentor was supervising me and continually told me to work slower but I was doing great performing some minor maintenance on a Clipper application and didn't even need his "stupid" help ... until I typed 'del _.db ' instead of 'del _.bak'. Oooops!

Luckily the woman whose computer we were working on clicked 'Backup my data' every single day before going home, bless her heart, and we could copy the database back from a backup folder. A 16 year old me was left utterly embarrassed and cured of flaunting his 1337 skillz.

</comment><comment><USER60> Obviously not the new engineer's fault. Unfortunately, aspects of this are incredibly common. On three jobs I've had, I've had full production access on day one. By that, I mean _everyone_ had it...

</comment><comment><USER61> After adding up the number of egerious errors made by the company, I'd almost be inclined to say the employee has grounds for wrongful termination or at least fraudulent representation to recoup moving expenses.

</comment><comment><USER50> Story sounds fictional to me.

</comment><comment><USER62> He's / she's better off not working at this place. So many things wrong. Not having a backup is the number 1 thing.

I could see having a backup that is hours old, and losing many hours of data, but not everything.

</comment><comment><USER63> Even startups have contracts with their customers about protecting the customer's data. If it is consumer data, there are even stricter privacy laws. Leaving the production database password lying around in plain text is probably explicitly prohibited by the contracts, and certainly by privacy laws. The CTO should pay him for the rest of the year and give him a great reference for his next job, in return for him to never, ever, ever, tell anyone where he found the production password.

</comment><comment><USER64> Here's why I think this is fake:

A company with 40 devs and over 100 employees that lost an entire production db would have surfaced here from the downtime. Other devs would corroborate the story.

<comment><USER65> I'm also skeptical, but this isn't necessarily true. There's plenty of software being written outside the HN bubble that's totally invisible to us. What if this was some shipping logistics company in Texas City? We'd never know about it; they wouldn't have a trendy dev blog on Medium.

<comment><USER64> Good point.

</comment></comment></comment><comment><USER66> I always wonder, why IT companies don't test their backups? Even if it's the prod db, it should be tested on a regular base. No blame to the dev.

</comment><comment><USER67> We were paying for RDS right from when we were a 2 man startup. Zero reasons to not have a dB service that is backed frequently by a competent team.

</comment><comment><USER27> He needs to return the laptop asap, like now. They are in full emotional mode and can overreact to what they might perceive as another bad act too.

</comment><comment><USER68> I don't work in tech but I'm an avid HN reader.

I'm surprised a junior dev on his first day isn't buddied up with an existing team member.

In my line of work, an existing employee who Transferred from another location would probably be thrown in at the deep end but someone who is new would spend some time working alongside someone who is friendly and knowledgable. This seems the decent thing to do as humans.

</comment><comment><USER69> Yeah this infra/config management sounds like land-mine / time bomb incompetence territory. You just were the unlucky one to trigger it. Luckily this gives you an opportunity to work elsewhere and hopefully be in a better place to learn some good practices - which is really what you're after as a junior dev anyway.

</comment><comment><USER70> Lucky junior dev! He has figured out a bad company to work for in his first work day. Good luck finding a new job!

<comment><USER71> Also, this is going to look great on their resumé, and be the perfect response to the "tell us a time when you made a mistake" interview question.

</comment></comment><comment><USER72> Everybody agrees that the instructions shouldn't have even had credentials for the production database, and the lion's share of the blame goes to whoever was responsible for that.

There is still a valuable lesson for the developer here though - double check everything, and don't screw up. Over the course of a programming career, there _will_ be times when you're operating directly on a production environment, and one misstep can spell disaster - meaning you need to follow plans and instructions precisely.

Setting up your development environment on your first day shouldn't be one of those times, but those times do exist. Over the course of a job or career at a stable company, it's generally not the "rockstar" developers and risk-takers that ahead, it's the slow and steady people that take the extra time and _never mess up_.

Although firing this guy seems really harsh, especially as he had just moved and everything, the thought process of the company was probably not so much that he messed up the database that day, but that they'd never be able to trust him with actual production work down the line.

<comment><USER73> No, sorry, and it's important to address this line of thinking because it goes strongly against what our top engineering cultures have learned about building robust systems.

> Over the course of a programming career, there will be times when you're > operating directly on a production environment, and one misstep can spell > disaster

These times should be extremely rare, and even in this case, they should've had backups that worked. The idea is to reduce the ability of anyone to destroy the system, not to "just be extra careful when doing something that could destroy the system."

> Although firing this guy seems really harsh, especially as he had just moved > and everything, the thought process of the company was probably not so much > that he messed up the database that day, but that they'd never be able to > trust him with actual production work down the line.

Which tells me that this company will have issues again. Look at _any_ high functioning high risk environment and look at the way they handle accidents, especially in manufacturing. You need to look at the overarching system than enabled this behavior, not isolate it down to the single person who happened to be the guy to make the mistake today. If someone has a long track record of constantly fucking up, yeah sure, maybe it's time for them to move on, but it's very easy to see how anyone could make this mistake and so the solution needs to be to fix the system not the individual.

In fact I'd even thank the individual in this case for pointing out a disastrous flaw in the processes today rather than tomorrow, when it's one more day's worth of expensiveness to fix.

Take a look at this: [https://codeascraft.com/2012/05/22/blameless- postmortems/](https://codeascraft.com/2012/05/22/blameless-postmortems/)

<comment><USER72> I violently agree with you.

All I'm saying is that there _are_ times when it is vital to get things right. Maybe it's only once every 5 or 10 years in a DR scenario, but those times do exist. Definitely this company is incompetent, deserves to go out of business, and the developer did himself a favor by not working there long-term, although the mechanism wasn't ideal.

I'm just saying that the blame is about 99.9% with the company, and 0.1% for the developer - there is still a lesson here for the developer - i.e., take care when executing instructions, and don't rely on other people to have gotten everything right and to have made it impossible for you to mess up. I don't see it as 100% and 0%, and arguing that the developer is 0% responsible denies them a learning opportunity.

<comment><USER19> Well, sure... but you cant expect one transitioning from intern status to first-real-job status to have the forethought of a 20-year veteran, nor should that intern/employee have the expectation that the company who is ostensibly to mentor him in the very beginnings of his career, would have such a poor security stance as to have literal prod creds in an on-boarding document, let alone not relegating whatever he was on-boarding with to a sandbox with absolutely no access to anything.

</comment></comment></comment></comment><comment><USER74> Cool story but I think this is fake. Since there are 40 people in the company, it seems like at least a few people before him followed the onboarding instruction. I just don't believe that there would be that many people that a) didn't do the same thing he did or b) change the document.

</comment><comment><USER75> Repeat after me, while clicking your heels together three times, "It is not my fault. It is not my fault. It is not my fault." It was obvious as I read your account that you would be fired. A company that allowed this scenario to unfold would not understand that is was their fault.

</comment><comment><USER7> I was only granted read-only access to the Prod DB last week, after achieving 6 months of seniority.

</comment><comment><USER76> I would assume this was mocked to test if the intern could follow simple instructions, to provide a lecture for the huge consequences of small mistakes and to have a viable reason to fire consequently; but I'm wearing my tin foil hat right now, too.

</comment><comment><USER77> It is really unfair to have fired him. The OP is not the one that sould have been fired. The guy in charge of the db should be fired and the manager who fired the OP should be fired too. And, by the way, the guy in charge of the backups too.

</comment><comment><USER10> Isn't this new person deserve a peer bonus by discovering a production risk?

</comment><comment><USER78> I would suggest you, once this sorted out, to publicly mention the company name so no other Engineer will fail in this trap again. This will be lesson for them to properly follow basic practices for data storage.

</comment><comment><USER79> Unfortunately, software companies like that are everywhere, the guy is learning and screws up a terribly designed system, the blame is on the "senior" engineers that set up that enviroment.

</comment><comment><USER80> My question is, why in the world did they publish someone's production credentials in an onboarding document? That has to be a SOX compliance violation at the very least.

</comment><comment><USER81> The CTO should be fired immediately!

If I didn't read wrong, they write poduction db credential in first day local dev env instruction! WTF.

This CTO sounds to me even worse than this junior developer.

</comment><comment><USER82> So a script practically set up the machine with the nuclear football by default, and then you where expected to diffuse it before using it. That is not your fault.

</comment><comment><USER83> I have a feeling the CTO was actually one of those "I just graduated bootcamp and started a website, so I can inflate my title 10x" types.

</comment><comment><USER84> Should have job title changed to Junior Penetration Tester and be rewarded for exposing an outfit of highly questionable competence.

</comment><comment><USER85> Firing the guy seems drastic but understandable. Implying that they are going to take legal action against him is ridiculous!

</comment><comment><USER86> So the company's fault. Embarrassing they tried to blame the new guy. So many things wrong with this.

</comment><comment><USER87> Wow. What a train wreck. This is why the documentation I write contains database URIs like:

USER@HOST:PORT/SCHEMA

</comment><comment><USER88> It was their fault, plain and simple.

<comment><USER89> How is it the FNGs fault that they have no backups, no DR plan, and production DB details freely available and in the setup guide? The company is entirely at fault.

<comment><USER90> I think the "their" was a plural referencing the company, not the dev.

</comment></comment></comment><comment><USER91> I really suggest that OP sends this thread to HR & others. And this isn't sarcasm

</comment><comment><USER92> What company is this? CTO deserves some internet slapping.

</comment><comment><USER93> Obviously not a ssae 16 environment.

</comment><comment><USER94> Either the CTO and his dev team are ridiculously stupid, or this was on purpose.

</comment><comment><USER95> Lots of people in the thread are commenting how surprised they are that a junior dev has access to production db. Both jobs I've had since graduating gave me more or less complete access to production systems from day one. I think in startup land - where devops takes a back seat to product - it's probably very common.

<comment><USER96> I work for a large bank as OPS engineer. The idea that I could even read a production database without password approval from someone else is too crazy to consider. Updating or deleting takes a small committee and a sizeable "paper trail" to approve.

Sometimes when I read stories like these, I think it's no wonder a company like WhatsApp can have a billion customers with less than 100 employees. And then I make some backups to get that cozy safe feeling again.

<comment><USER97> Probably because your industry is regulated.

</comment></comment></comment><comment><USER98> Name and shame.. The CTO stinks of incompetence, and surprised he/she has managed to retain any competent staff (perhaps he/she actually hasn't). What a douchebag. You are not to blame.

</comment><comment><USER99> I worked with someone who did this, early in my career. His bacon was saved by the fact that a backup had happened very soon before his mistake.

His was worse though, because he had specifically written a script to nuke all the data in the DB, intending it for test DBs of course. But after all that work, he was careless and ran it against the live DB.

It was actually kind of enlightening to watch, because he was considered the "genius" or whatever of my cohort. To wit, there are different kinds of intelligence.

</comment><comment><USER100> I fucked up a table once by setting the column of every record to true, but I had asked about changing the code to require a manual sql query a few weeks prior so it could have been prevented.

</comment><comment><USER101> People are designed to make mistakes. We should learn from them and try to be more understanding.

</comment><comment><USER102> Understandable that hey got fired. I image there would have been a quite emotional response from the business when this happened, but that doesn't mean it was necessarily the most appropriate response.

\--Unfortunately apparently those values were actually for the production database (why they are documented in the dev setup guide i have no idea).--

Someone else should have been fired if this is true.

<comment><USER53> No, it's inappropriate. When the process fails you don't fire the junior employee that showed you just how incompetent the organization is. You fix the problem.

Firing this guy does nothing, fixing the problem does, but requires those higher up to admit the mistake was theirs to begin with.

<comment><USER102> I should clarify, I don't think its appropriate, But I see why it happened. The business was panicking. His firing was kinda on the cards. Probably a blessing in disguise for this guy.</comment></comment></comment>


Startup Quote: Chuck Gordon, co-founder, SpareFoot - <AUTHOR> http://startupquote.com/post/5816030371

<comment><AUTHOR> You need to fail quickly. If you think you know what's going to work in any aspect of your startup, you are wrong.

\- Chuck Gordon (@sparefoot)

<http://startupquote.com/post/5816030371></comment>


Web Bolshevism: Google's rel canonical nofollow patchy mess - <AUTHOR> http://zminer.com/content/web-bolshevism/

<comment><USER2> "There was a moment in time where Google decided to be not a participant, but a coordinator of the WWW. And that's where things started to break down. The web is uncontrollable, like nature, and Google is turning it into their very own Jurassic Park. The problem is, the Velociraptors have escaped their cages." = GOLD IMO

<comment><USER3> You meant BOLD? No wonder the author has that part in bold :p

seriously tho i like the article - the www must remain free and google's interference is already overwhelming. i'm not saying it's negative interference, it's just too much interference if you know what i mean. ads, etc, guidelines, rules dictated and what not. where is the good ol free www?

</comment></comment><comment><USER4> "The search field covers the content of the site, if you were searching and a match was under the field, or you wanted to click a link/button under the search field, you're out of luck."

or are you?

[http://littlebigdetails.com/post/6000057345/chrome-if-a- resu...](http://littlebigdetails.com/post/6000057345/chrome-if-a-result-is- behind-the-search-form-it)

</comment><comment><USER5> Interesting article. I think Google is the most innovative company out there and their success clearly reflects that. But the way they've been handling the web lately does not please me. They shouldn't guide the web, the web should guide them. Web bolsheviksm is an interesting term, i think it'll catch on for this sort of initiative.</comment>


RIM on Apple's claims of Blackberry Bold signal loss - <AUTHOR> http://crackberry.com/rim-official-statment-response-apples-iphone-4-antenna-propaganda

<comment><USER2> If the antenna is internal (and invisible) how many would even realise they were affecting it in any way? Apple drew a lot of attention to its antenna, both in terms of design and marketing, so how many people reported problems after deliberately trying to screw with it?

I just made my iPhone 3GS, Blackberry 9700 and Nokia N97 all drop a couple of bars by covering their internal antennas with my palm. I expect this to happen with any phone.

<comment><USER3> The point is that you can have the same effect on an iPhone 4 with your pinky.

<comment><USER4> Though the ease of producing the problem on the iPhone 4 is very real, this argument annoys me:

No one touches their pinky over that line in normal use. Does it cause a problem? Yes. Does anyone just sit there with one finger on the side of the phone? No.

Instead, say that a grip natural to a large number of users causes signal loss.

<comment><USER5> I do touch the line with my pinky in normal use all the time. Maybe I have an abnormally shaped hand, I don't know. That being said, I love my new iPhone 4, I'm a new convert from Android and I don't really have reception problems.

<comment><USER4> That's legitimate, but the problem isn't "your pinky touches the line" its "my grip (and it's not an odd grip) causes my pinky to touch the line".

People making videos of an iPhone on a table, and one finger coming up and touching it are alarmist ways of treating the problem. Not that its not a very serious real problem, but let's be reasonable and only talk about the issues it has when we're actually using it.

</comment></comment></comment></comment></comment><comment><USER6> Ask the average iPhone 4 user: would you rather have the new antenna design, which generally considerably outperforms the old design (not to mention all the side benefits such as making the device so thin and strong), or would you like a design like the 3GS back, which outperforms the 4 in one specific circumstance that doesn't seem to affect most people in real usage?

<comment><USER7> Something this whole sordid saga has made me appreciate is that the 3GS is really a damned awesome phone. It feels good in my hand, it can run IOS 4 without slowing to a crawl, its proximity sensor works well, and it doesn't tend to drop calls or not drop calls based on how it's held. It was designed before Apple got complacent, and it shows.

My SO has an original 3G model and it feels a lot slower, even without upgrading to IOS 4. I was going to upgrade both our phones when the iPhone 4 was first announced, but I failed to get our pre-orders in on time, and now I'm sort of glad -- especially since I'm not the one stuck with the slower 3G. :)

</comment></comment><comment><USER8> Did you notice RIM didn't deny it?

<comment><USER9> I can't reproduce it on my bb curve 9800

<comment><USER10> point?

<sorry, inside joke to one of grandalf other comments>

<comment><USER9> Hah. Well, I followed the procedure blackberry that I read causes the bars to decrease in the iphone 4. There was no decrease whatsoever.

<comment><USER11> Do you understand that this is related not just to how you hold the phone, but where you are and what reception you are getting. There are plenty of people (most?) that can not produce this on the iphones either.

<comment><USER9> I wasn't attempting to insinuate that all iPhone 4G's are easy to trigger this in, but I wanted to defend Blackberry from the unfair attack by Apple. I have had a few Blackberries and none have ever had any noticeable hand position related signal loss across a variety of signal strength and location environments.

<comment><USER11> How is this an unfair attack? It is not an attack at all, it is simple physics. All phones have this problem, the media are focusing on just one phone, because it is more newsworthy. Apple are saying it is a problem with most phones out there, the iPhone is no different. You really see that as an attack.

</comment></comment></comment></comment></comment></comment></comment><comment><USER12> "Apple's attempt to draw RIM into Apple's self-made debacle is unacceptable. Apple's claims about RIM products appear to be deliberate attempts to distort the public's understanding of an antenna design issue and to deflect attention from Apple's difficult situation. RIM is a global leader in antenna design and has been successfully designing industry-leading wireless data products with efficient and effective radio performance for over 20 years. During that time, RIM has avoided designs like the one Apple used in the iPhone 4 and instead has used innovative designs which reduce the risk for dropped calls, especially in areas of lower coverage. One thing is for certain, RIM's customers don't need to use a case for their BlackBerry smartphone to maintain proper connectivity. Apple clearly made certain design decisions and it should take responsibility for these decisions rather than trying to draw RIM and others into a situation that relates specifically to Apple."

\- Mike Lazaridis and Jim Balsillie

</comment><comment><USER13> I wish they would post actual measurements, as in Anandtech analysis articles. A video is nice, but are there any dB measurements out there?

</comment><comment><USER14> Crackberry's call for duplication

 _Apple's test? Go to an area where you have full bars while holding the phone gingerly, then change that loose grip to a bit more of a death grip._

is flawed given that "full bars" can indicate an arbitrarily strong signal. In order to see the effect Apple demonstrated you will most likely need to be in a location where you just _barely_ have "full bars".

Why are we linking to a website that either doesn't understand the how the "bars" work on phone or is only trying to add misinformation the discussion?

<comment><USER15> The statement itself was issued by RIM. I'm pretty sure they know a thing or two about bars and antenna design.

<comment><USER14> I too am pretty sure RIM knows about about antenna design which is why they didn't deny Apple's claim that many, including their own, smart phones are subject to a grip of death. crackberry (which is what the OP linked to) however insinuate (through their flawed survey) that it wasn't.

<comment><USER9> I could not make my bb curve lose any bars from gripping, holding, etc. I tried very hard...

<comment><USER16> Just like there are people not being able to reproduce the problem on their iPhone 4.

<comment><USER9> Point?

<comment><USER10> The point is the single data point you are providing. Finding iPhone 4 users with this same data point of not having a problem point to the fact the you entirely missed the point.

<comment><USER9> I thought that with any iphone 4 in all but the strongest signal areas it was possible to cause a decrease in measured signal by doing the death grip.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER17> So every telephone can get signal attenuation if you hold it in a certain fashion in certain reception conditions. That sounds plausible, although I never experienced the problem with my bb bold, I'm ready to accept this problem can be reproduced.

That's not the issue at hand. The issue with the iPhone 4 is that it's very easy to drop calls and get signal attenuation. The reports are too numerous to be just a sporadic problem. Whether this is a problem in the manufacturing process (which would explain why not all telephones have the problem) or the design, only Apple knows.

At first they say there is no antenna problem. Then they say it's a bug in the software. Now they say "well all phones have this problem".

I think inspector Columbo would say "Aahh! Of course, all phones have the problem... Now Mr. Jobs, just one more thing..."

<comment><USER18> First. If the problem is as widespread as you think, how do you reconcile that with AT&T's dropped calls statistics that show that it drops _less than 1%_ more calls than the iPhone 3GS?

Second. How do you reconcile it with AnandTech's tests that show that the iPhone 4 is _better_ at keeping calls even with a poor signal?

<comment><USER19> It is one or less percent unit more, which means that if the 3GS drop rates are 1%, the 4 has drop rate of 2% which is 100% more dropped calls.

I made some research on this and found <http://arxiv.org/pdf/physics/0210022> which says basically that drop rates among 720 different carriers have a lognormal distribution with mean of about 2.4%.

iPhone 4 might have better RF and baseband chain to compensate, but it's clearly not enough when the phone seems to lose the signal altogether.

Edit: Jobs said clearly that the 4 drops ~1 calls more per 100 than the 3GS. 1 per 100 -> 2 per 100.

<comment><USER20> Unfortunately, you're misunderstanding what Jobs said. They said it drops ~1 call per hundred than the 3GS, not 1 percentage point more. That's a huge difference. It means that if the 3GS drops 1% of calls, the iPhone 4 drops 1.01% of calls.

<comment><USER19> What? I don't really get my head around your math or I just misunderstand what you are trying to say. 1 call per 100 calls means one percentage point.

Jobs said: "One or less additional dropped call per hundred calls". I don't know how I should parse this to be "one percent more dropped calls than 3GS".

</comment></comment></comment></comment></comment><comment><USER21> My BB Bold 900 looses a bar or two if I cover it in a way that it would be impossible for me to make calls then. Never had any issues with it, never drooped a call. But to be fair, I'm in Slovenia in Mobitel's network which is one of (if not) the best in the world. So maybe all this problems come from crappy network services too.

<comment><USER22> Jobs clearly stated that the demo of bars being dropped on other brands of phones was done in an area of bad network reception. If people try the death grip with good network reception they won't see any drop in bars. As I understand, this is the same for the iPhone 4.

<comment><USER23> In the real world, sometimes there is bad network reception. Then there are people who can still make calls in that area, and people who can't.

<comment><USER22> Yes, but that might account for why this guy isn't able to reproduce the bar drop.

</comment></comment></comment></comment><comment><USER24> Does putting the magical and revolutionary attenuation-solving Apple bumper onto a Blackberry Bold help? :)

</comment><comment><USER25> I tried apples test on my phone and no go.

<comment><USER8> I tried it on the 3GS with the antenna inside. It loses bars.

</comment></comment><comment><USER26> They should sue Apple for false claims.

<comment><USER8> It isn't false. RIM didn't deny it loses bars when held a certain way. They were just pissed that that Apple showed it to be true. Apple _did_ show it to be true so there is no false claim.

<comment><USER19> They are really comparing apples to oranges in the sense that they didn't talk about the iPhone's design flaw, just RF shadowing which is obvious.

There isn't any phone other than iPhone that loses the signal altogether by just touching one point on the phone.

<comment><USER27> > There isn't any phone other than iPhone that loses the signal altogether by > just touching one point on the phone.

Perhaps, but I'm not entirely convinced that is true. It may be, but it may also be true that other phones do have a one point weakness which isn't marked by a visual cue. It's just that no one has tested a large selection of phones to locate that one point.

Of course, I'm not sure why it matters whether a pinky can drop dB ... you can't hold a phone with just 1 finger touching the side. This is just as much of an issue as arguing all phones have a major weakness because they drop dB when wrapped in aluminum foil.

</comment></comment></comment></comment><comment><USER28> Did Apple even attempt to provide evidence of the Blackberry having a similar problem?

<comment><USER29> They showed a video of the Bold 9700 having a death grip issue which probably also effects very few people in real world usage. (13% of 9700 owners based on this site's poll)

<comment><USER30> I have a Bold 9700 and have never had a problem of this kind.

<comment><USER31> I have an iPhone 4, live in terrible coverage, when this blew up took it out of the bumper for past two weeks, and can't drop a call even in places my 3GS and Blackberry Pearl couldn't make calls _at all_... And so?

Bandwagons roll on squeaky wheels.</comment></comment></comment></comment>


PyTorch vs. TensorFlow: 1 month summary - <AUTHOR> https://www.codementor.io/dmonn/pytorch-vs-tensorflow-1-month-summary-d8o0kas25 <comment> J0-nas > A forward() function gets called when the Graph is run.

Isn't that almost exactly the same in tensorflow? You'd run your model to generate an output, or/and run your optimization operation t optimize the model.

> Based on some reviews, PyTorch also shows a better performance on a lot of > models compared to TensorFlow.

Citation needed. How good are the examples optimized? What does performance mean? Precision or learning iterations per second?

If it's the later, in which environment? CPU/GPU/distributed computing?

<comment><AUTHOR> > A forward() function gets called when the Graph is run.

Yes, the idea behind it is the same. The difference: PyTorch has a forward() function in their module class which you have to override, while in TensorFlow you can specify that yourself.

> Based on some reviews, PyTorch also shows a better performance on a lot of > models compared to TensorFlow.

E.g.

[http://deeplearningathome.com/2017/06/PyTorch-vs- Tensorflow-...](http://deeplearningathome.com/2017/06/PyTorch-vs-Tensorflow- lstm-language-model.html)

</comment></comment><comment><USER2> While I think that this is a somewhat useful rough overview, it should have had some more details about the actual differences and in particular how to accomplish the same thing with some code examples in each library.

On a side note: I know that I can also link tensorflow directly to a C++ application instead of using it with python. Can the same be done with pytorch?

<comment><AUTHOR> AFAIK there are unofficial C++ Torch Interfaces, but nothing official.</comment></comment>