Things I Hate About PostgreSQL (2013) - <AUTHOR> http://kupershmidt.org/pg/10_Things_I_Hate_About_PostgreSQL/#/ <comment><USER2> I somewhat agree, and somewhat have the opposite view:

I __love __psql and tab completion, it 's magic, in fact it spoiled me, I know have a hard time to work on any other DB.

Not mention in the article, but I love how the postgres dev keep up with modern SQL. Again it makes it really hard to go back on a SQL 92 compliant system.

Now, the vacuum business, that's horrible. I've run into so many case where "vacuum full" just solve the weirdest problems. One very recently where I use postgres as a queue (because it was easy and works across platform/clouds) nad it became slow and horrible even though I had dropped a bunch of schemas. "vacuum full;" oh wow!

The replications story is ugly. You can make it work, but it's literally a craft and you end up having to babysit it.

One the author missed, lots of weird performance issue, got my answer from the uber post. The rule #1 of adding indices is to only use column that you really really need, because otherwise you're going to slow down your writes. Well, it turns out not on postgres, all indices for the table you're writing to are being updated! I'm pretty sure very few people were aware of that before uber told us.

The more I use the postgres front end (psql, SQL) the more I love it, but the backend (performance, replication) is starting to taste more and more sour.

<comment><USER3> Really? Coming from PGSQL to a MySQL-only shop made me really miss PGSQL's performance. Sure, MySQL is faster on `select pk from tbl where pk=1`, but the second you get into complicated joins, including subqueries, or doing _any_ analytics the performance is very random.

With pgsql, I can get a clear concise explain and if I disagree with what's happening (because I know exactly what my hardware is capable of) I can tune any query to be decently performant.

With mysql, you get... I mean explain is ok, but I wouldn't put it above that. "EXPLAIN ANALYZE" is my gold standard forever and ever. I even liked it more than SQL Server's equivalent; which is also fantastic.

<comment><USER4> MySQL's lack of CTEs is particularly annoying. Even SQLite has supported them for some time now!

I've seen this cause MySQL query authors to use various workarounds that end up impacting the query performance negatively.

<comment><USER5> I suspect MySQL is used with more bare bones schemas, without as many SQL function and complex triggers, as it has worse support for those (IMO, as someone that used MySQL). This does have the side effect of making it very ORM friendly, and the more you rely on an ORM the less you care or even know what queries are being run under the covers.

</comment></comment></comment></comment><comment><USER6> There's really only one thing I dislike about pgsql. It seems overly difficult to return two disjointed result sets from a stored procedure/function. This is fairly common and easy in MSSQL. It also is easy in MySQL. Something like this:

SELECT int_col_1, int_col_2 FROM table1

SELECT varchar_1, varchar_2, int_col_2 FROM table2

In pgsql if the columns are the same type and number then we can use a union, otherwise the suggested alternative seems to be to just make 2 queries.

<comment><USER7> What is a good example of when you'd want to do that? I've been doing database work on the 4 majors for about 15 years and this is the first I've ever heard of somebody wanting to return two totally different result sets from a single procedure.

I have no issue with putting logic in your database. In many cases it's the ideal solution...but your example is something I've never even heard mentioned in 15 years much less advocated for or used as criticism for not being available.

<comment><USER8> One place I worked used a disconnected data set model. The idea was a single stored procedure returned multiple result sets all relating to a single business entity; specifically, an insurance quote, along with all the drivers, vehicles, accidents, convictions, etc. The entity was locked by inserting a row in a table.

Thereafter, the application didn't communicate with the database until it was time to save the record. The disconnected data set was small enough to store in shared session store, or even in a cookie (encrypted, naturally).

This architecture had a number of interesting knock-on effects. The entire state of a client's conversation with the server was tiny and entirely encapsulated by this disconnected data set, so you could record and play back each request to recreate a bug.

It didn't have to use multiple result sets from the stored procedure, but it did save a bunch of round trips.

<comment><USER9> >... or even in a cookie (encrypted, naturally).

I won't comment on anything else because I don't know the case, but you should never put user data in cookies. Even with encryption you are exposing it unnecessarily, not to mention you have to double check data integrity... Why? Cookies are not meant for this.

</comment></comment></comment></comment><comment><USER10> The slides are from mid-2013, how many points are still valid? Has there been progress in the last 3 years?

<comment><USER11> The google thing gets worse every release.

The Django project fixed it by adding canonical links to all the docs, see for example view- source:[https://docs.djangoproject.com/en/1.9/ref/models/querysets/](https://docs.djangoproject.com/en/1.9/ref/models/querysets/) (Has a <link rel="canonical" href="[https://docs.djangoproject.com/en/1.10/ref/models/querysets/...](https://docs.djangoproject.com/en/1.10/ref/models/querysets/">))

The postgres project _really_ needs to do that. It's a mess.

</comment></comment><comment><USER12> Sublime Text works well for me as a Postgres query editor. Rock solid super fast, unlike all alternatives, (I've tried them all) except psql, which is solid but ugly. ST3 has for me a much nicer interface and has amazing search and replace ability, attractive themes, syntax highlighting from pg specific plugin. Remarkably it even copes with queries that return millions of rows. You can control it's behaviour with the same config options as psql, full feedback error messages, line numbers etc Easy to setup build system, see [http://blog.code4hire.com/2014/04/Sublime-Text-psql-build- sy...](http://blog.code4hire.com/2014/04/Sublime-Text-psql-build-system/)

<comment><USER13> Have you look at DataGrip? ([https://www.jetbrains.com/datagrip/](https://www.jetbrains.com/datagrip/)) Been using since it was in beta, and it handles SQL Server and Postgresql well. (haven't used it for other platforms yet)

</comment></comment><comment><USER14> I always enjoy good critique. There was a similarly excellent talk about the differences between Python and Ruby, which discussed the strengths and weaknesses of the design choices each made. It was _fascinating_. Unfortunately, I can't remember the link...

<comment><USER15> Maybe [http://www.wikivs.com/wiki/Python_vs_Ruby](http://www.wikivs.com/wiki/Python_vs_Ruby) or one of the links at the end of that page?

<comment><USER16> Extra relevant link cause when you try to go to 'main page' from that article you get a postgresql error!

</comment></comment></comment><comment><USER17> I know a lot of people use Postgres (myself), and I was looking at the source recent, it seems pretty high quality. Makes it all the more surprising that there aren't really any performance tests.

Reviewing and pulling things in is always hard, though. In other software I highly recommend _always_ breaking up big things into smaller changes if possible, but I don't know if that works well for the conservative release cycles for DBs.

Though maybe the conservative release cycle is what's wrong? Having to do a refactor to implement a feature doesn't mean that you need to do both at once.

</comment><comment><USER18> Oddly, I don't see anything about managing user permissions, access, and authorization. It's wicked arcane compared with every other DB out there. I believe one main reason MySQL caught on early with hosting providers was because of this.

<comment><USER19> That's odd, I feel the opposite. For years the way to create a user in MySQL was this:

        grant usage on *.* to 'bob'@'localhost'
          identified by 'itsasecret';

Meanwhile, PostgreSQL had the extremely straightforward "createuser" command line tool, and the "create user" SQL statement. (MySQL got "create user" and "alter user" around 2006 or so.)

Having to edit pg_hba.conf to allow network connections was always an annoyance for me, but at least the error message you get if it's set up wrong _tells_ you to edit that file, which is also very straightforward and contains documentation out of the box.

Not allowing external access by default is arguably a security practice, though I always thought distro maintainers ought to have erred on the side of usability by enabling localhost access by default.

</comment></comment><comment><USER20> The main thing I've hated about postgres over the years is pgadmin3. Haven't had to use it for a while but it was always easy to get it into a pickle in common situations, like losing the connection to the database.

<comment><USER21> Have you tried pgadmin 4? It's a complete rewrite.

<comment><USER22> It looks pretty awkward to me. I don't get why they felt it's a good idea to do it in a browser with spaghetti-bowl of jQuery full of second-long animations.

<comment><USER23> It is indeed awful, albeit functionally superior to pgAdmin III.

</comment></comment></comment></comment><comment><USER24> One thing that I really wish existed was a comprehensive guide to vacuuming, transaction id wraparound and similar issues. There have been a few posts recently that discussed problems that arise, but what I haven't seen is a sort of comprehensive "here are the issues that exist, here is what you must monitor in order to be safe" type of guide. The official docs are helpful, but fall short of that kind of guide, and none of the posts I've seen are really comprehensive.

Unfortunately, I'm pretty new to postgres and can't write it myself.

<comment><USER22> I found this to be great introductory that touches on all the major points to keep in mind with Postgres. It's pretty up-to-date too!

[https://www.youtube.com/watch?v=knUitQQnpJo](https://www.youtube.com/watch?v=knUitQQnpJo)

It isn't quite what you ask for, but should be enough to get you high-level overview of major systems and contains solid practical advices (on vacuuming, mvcc, replication, backups, etc…), so you know what to google for deeper understanding.

<comment><USER24> Thanks! It's too long for me to watch right now, but I've saved it for the next time I can dedicate that much time to a video.

<comment><USER22> Feel free to skip to any topic, it is quite well structured to do that.

</comment></comment></comment></comment><comment><USER25> I'd be all over pgsql if replication wasn't such a mess. Yes it works (presumably), but I can't find any useful (e.g. informative) information on a comparison between (the many??) methods to go about it and/or most modern way to accomplish it.

If anyone here knows of a good source, I'd love to see it :D (If you use the word "just" or link me the docs, you're dead to me).

<comment><USER4> Why do you reject the documentation? It has exactly what you're asking for:

[https://www.postgresql.org/docs/current/static/different- rep...](https://www.postgresql.org/docs/current/static/different-replication- solutions.html)

It describes the various methods that are available, it lists implementations of each, it explains the tradeoffs involved, and so on. Table 25-1 summarizes the information.

Regardless of the database system being used, replication is just inherently complex. There isn't really a one-size-fits-all solution. The method to use depends on the requirements and context of a given implementation.

</comment></comment><comment><USER26> I really like the slideshow UI. Anyone know which software was used to make this?

<comment><USER27> This is made with Reveal.js, but there is another one as well called Impress.js, they seem quite equal.

[0] [https://github.com/hakimel/reveal.js/](https://github.com/hakimel/reveal.js/)

[1] [https://github.com/impress/impress.js/](https://github.com/impress/impress.js/)

</comment></comment><comment><USER28> 10 slides in, and I realize that my back button is fucked.

Why do people do this?

<comment><USER29> If I was doing slides like this, it would be because I was going to use them in a talk. Then I would want the back button to go back one slide.

If I then put them on the internet, I may not bother editing them to make the more "internet friendly".

<comment><USER30> But how would you go forward in the first place? Not with the "Forward" button, because you haven't visited the page yet.

Instead, you press "Right" or "PgDn" or what have you. So I would expect the converse button ("Left" or "PgUp") to go back a slide as well (which it presumably does).

That leaves the browser's Back button to go back to the previous web page.

Everybody's happy!

<comment><USER31> > _That leaves the browser 's Back button to go back to the previous web page_

Why approach 10+ slides as "a single page"?

If you consider them as 10 web pages, the back button makes sense to go back one page. Same for the left button, given the "presentation" use case.

And if they were actually designed as webpages, with html links taking you to slide2.html, slide3.html etc., that's exactly what you would get.

So if anything, whether this is a SPA or not, this is more in tune with how the internet works, and how it was designed to work.

<comment><USER32> This way a person can link to a particular page.

<comment><USER31> You CAN link to a particular page. Here, page 14.

[http://kupershmidt.org/pg/10_Things_I_Hate_About_PostgreSQL/...](http://kupershmidt.org/pg/10_Things_I_Hate_About_PostgreSQL/#/14)

</comment></comment></comment></comment></comment></comment><comment><USER33> Just needs a [2013]

</comment><comment> alex-yo Yey, looks like people just watch presentations, not read it, that's why here is 1 comment about the content, 15 about how the presentation looks like :)

<comment><USER34> I'm not even able to read it. I can't figure out how to go forward from the title page.

<comment><USER31> Since time immemorial, the way to go forward in such pages is to press the left and right arrow buttons.

This has worked in 99.9999% of presentations uploaded on the internet and posted on HN.

It's also very intuitive to try, since this is how it is in any presentation desktop app too.

<comment><USER35> > Since time immemorial, the way to go forward in such pages is to press the > left and right arrow buttons.

"Time immemorial"? Damn, I remember pretty clearly what life was like before Web 2.0, and I'm still in my 20s. The first time I encountered one of these presentations I was confused as hell, at least this one has the decency to put arrows to click in the bottom right corner, a lot of presentations don't.

<comment><USER31> > _I remember pretty clearly what life was like before Web 2.0, and I 'm still > in my 20s_

Well, I'm in my late thirties, and "before web 2.0" is "time immemorial" in tech years.

> _The first time I encountered one of these presentations I was confused as > hell_

Yeah, but that should have been like 5-10 years ago. How come people still don't get them?

Heck I was confused as hell when I first encountered DOS, mice, GUIs, UNIX, browsers, etc back in the day. But we learn and move on. What puzzles me is that HN is not full of "average users" but devs and technies, and also the fact that such presentations are posted tons of times a month, and yet someone still asks...

(Sure, I can understand that this could imply a "fundamental non intuitiveness" of such UI, but whether it's intuitive or not when we first meet it, it should be second nature by now.

I believe in "idiom based design" over intuitiveness (which constraints us to UIs that we can understand at first glance, preventing designs that could need a little getting accustomed to, but be far more powerful in the long run).

And I'd argue it's not even that non-intutive. From games to Powerpoint, all kinds of apps use the arrow keys to navigate -- why wouldn't one at least try them?

<comment><USER35> > How come people still don't get them?

The reason these comments keep appearing is because tech community is large & growing and each person encounters & is confused by their first presentation in this style at a different time. As much as I hate the relevant xkcd meme, it is pretty apt here: [https://xkcd.com/1053/](https://xkcd.com/1053/)

> Mice

This isn't a good analogy because you are in control of whether you use a mouse or not. If it confuses you, you'll either stop using it or figure it out before participating on HN. OTOH you can surf the web for years without encountering one of these presentations, so it's jarring when someone else creates a web page that violates your expectation of how the web works

> And I'd argue it's not even that non-intutive. From games to Powerpoint, all > kinds of apps use the arrow keys to navigate -- why wouldn't one at least > try them?

Because people are used to navigating the web with their mouse, not their keyboard

</comment></comment></comment></comment></comment></comment><comment><USER36> What an awful format for slides.

<comment><USER37> Besides the fact that the font is really tiny, it's actually much nicer on phone than most of the "n things..." websites which seem to try and maximize clicks.

<comment><USER38> The font is _too_ tiny. I couldn't read the mono space parts.

<comment><USER39> Really? It all looks perfectly legible for me on FF and Chrome, on both win + lin. It'd be even more so if fullscreened like you'd expect a slideshow to be presented.

<comment><USER38> Probably, but the context here was mobile. The monospaced parts are too tiny on my iPhone 5c.

</comment></comment></comment></comment></comment><comment><USER40> Website is broken. UX fail.

<comment><USER31> It's amazing that in 2016 people still don't know to press left and right arrows (or spacebar) in an online presentation.

It's the way ANY slideshow works, on desktop and online form. And it's a trivial thing to try, even when not told to. Not to mention by now there have been around 1000 such slideshows posted on HN.

<comment><USER41> > It's amazing that in 2016 people still don't know to press left and right > arrows (or spacebar) in an online presentation.

It's amazing that in 2016 people still don't fall back gracefully in the absence of JavaScript and/or CSS.

<comment><USER42> Sorry, but no it's not. You're in the extreme minority if you don't have JS or CSS. It's simply not even worth the time to cater to you.

<comment><USER41> > It's simply not even worth the time to cater to you.

That attitude is evil. That attitude underlies much (albeit not _all_ ) that is wrong with the Web in 2016. That attitude is wrong.

Espousing that attitude evidences a profound failure to understand the value of the Web.

</comment></comment></comment></comment></comment><comment><USER43> [http://www.wikivs.com/wiki/MySQL_vs_PostgreSQL](http://www.wikivs.com/wiki/MySQL_vs_PostgreSQL)

</comment><comment><USER44> I still don't understand database systems, how they work internally, and what problem they really solve.

It seems that new paradigms like R and RAM-only key values system are just simpler, faster and cheaper in programmer time. Loading everything in RAM and do a search seems like a huge saving of time and just works for most cases. Usually if you have more complex needs, you need to adapt your solution, and databases don't seem like a silver bullet.

Database queries seem like a solution to the problem of storing data on disk when RAM was too expensive. So today it's still used as some sort of standard, but when you can have 16GB of ram, I think you better teach yourself what sort of algorithm and data structures a database use to be faster, use the ones you like and need and solve your problem case by case.

The example of how reddit store its data is pretty demonstrative that ultimately, you should not let a database system do all the work. Databases are just a file format to me, but the way it tries to work for you at a lower level will respond to basic cases, but when you increase complexity it's not relevant anymore.

Especially today when you have big data and machine learning, everyone should just learn to understand data manipulation. Not saying to teach yourself C all over again, but having a decent idea of the math of what indexing is really about. Forcing yourself to use a database because the company always used it isn't appealing to me.

It's like one of those things when a programmer had an idea which is based on a constraint, everyone starts using it, several products are made, but nobody really remember the original idea of the inventor of that paradigm.

<comment><USER31> > _I still don 't understand database systems, how they work internally, and > what problem they really solve._

The use a formal, mathematical abstraction (relational algebra), even if somewhat crapily implemented by particular RDBMS, to facilitate saving data, relationships between data, and queries, while at the same time assuring certain properties (e.g. ACID) and doing so in a platform/programming language neutral format and with a consistent and industry standard query interface.

NoSQLs, key-stores and the like are not newer developments -- they predate databases. They were found to be a bad fit for what we wanted in enterprise use, and RDBS caught on.

For uses with huge data (Google and such scale) a denormalised approach might be more practical for performance reasons, in which case developers and ad-hoc programs get to re-implement all the functionality and assurances of a RDBMS in an ad-hoc way on top of rawer stores. (And all this could be alleviated with a properly optimised RDBMS for such purposes the still respects relational algebra).

In a conventional enterprise setting on the other hand, a DB trumps NoSQL etc solutions any day of the week.

> _Database queries seem like a solution to the problem of storing data on > disk when RAM was too expensive. So today it 's still used as some sort of > standard, but when you can have 16GB of ram, I think you better teach > yourself what sort of algorithm and data structures a database use to be > faster, use the ones you like and need and solve your problem case by case._

The whole idea is to free the data from being tied to a particular language, data structures and algorithms.

Back in 2000-2007 it was all about XML, and how we should store data in XML format and get them back with XQUERY, XPATH and the like. A lot of people bought into the hype and the resulting products. Then it was about JSON -- and we now have JSON stores. In 10 years, it will be something else, again ad-hoc.

Meanwhile SQL has worked for the past 3+ decades, and is based on a solid mathematical abstraction (relational algebra).

> _It 's like one of those things when a programmer had an idea which is based > on a constraint, everyone starts using it, several products are made, but > nobody really remember the original idea of the inventor of that paradigm._

You'd be surprised. Or rather you're exactly right -- few "really remember the original idea of the inventor of that paradigm", and that's why we're moving in circles with ad-hoc technologies re-implemented 30+ years after they were discarded. Or why people jumped enthusiastically to Mongo to return crying back to PostgreSQL.

Read a little around here for example:

[http://www.dbdebunk.com/2015/07/the-sql-and-nosql-effects- wi...](http://www.dbdebunk.com/2015/07/the-sql-and-nosql-effects-will- they.html)

[http://www.allanalytics.com/author.asp?section_id=2386&doc_i...](http://www.allanalytics.com/author.asp?section_id=2386&doc_id=280912)

[http://www.dbdebunk.com/2015/11/moving-in-circles-sql-for- no...](http://www.dbdebunk.com/2015/11/moving-in-circles-sql-for-nosql.html)

<comment><USER45> JSON is just as much rooted in math as SQL tables - it is `fix T = FiniteMap String T` plus a few primitive types, while SQL is `Collection (Set [String])` plus a few primitive types.

Of course, SQL has a nice efficiently-implementable algebra of set comprehensions, which may or may not be interesting for your particular use- case.

<comment><USER31> > _JSON is just as much rooted in math as SQL tables - it is `fix T = > FiniteMap String T` plus a few primitive types, while SQL is `Collection > (Set [String])` plus a few primitive types._

It's not the tables that make SQL what it is, it's the relations.

Heck, it could even not have any types at all (a la dyamic languages or Sqlite), and relational algebra as an abstraction would still hold.</comment></comment></comment></comment>


28 things people had achieved at the age of 28 - <AUTHOR> http://www.theguardian.com/culture/2013/oct/16/28-things-people-had-pulled-off-at-the-age-of-28

<comment><USER2> Since Jimi Hendrix, Janis Joplin, Jim Morrison, Kurt Cobain and Amy Winehouse never got past 27, so I don't see why this list would even matter.

</comment><comment><USER3> Oh f*ck. I feel the pressure.

</comment><comment><USER4> Life isn't a race.</comment>


Show HN: Git alias commands and shortcuts - <AUTHOR> https://github.com/GitAlias/gitalias
Do you use git? I have a big list of alias commands and shortcuts that I'm sharing on GitHub.
I'm seeking suggestions and feedback now, and also seeking pull requests to improve the code. <comment><USER2> If you are a oh-my-zsh user, the Git plugin has tons of aliases ready to use: [https://github.com/robbyrussell/oh-my- zsh/wiki/Plugin:git](https://github.com/robbyrussell/oh-my- zsh/wiki/Plugin:git)

<comment><AUTHOR> Thanks! I'll add this to the README now.

</comment></comment><comment><USER3> I do something similar to this, except I just use my shell's alias do to this. e.g., alias gits="git status".

If you're like me and have a weird habit of just typing stuff into the terminal during the day, "gits" (or "git s" if you use OP's stuff) will become one of your most typed commands.

<comment><USER4> For me, it's bash functions "st" (or "sq" to skip untracked); I also made them such that they DTRT in svn, hg, darcs as well. Probably my most used commands :-)

</comment></comment><comment><USER5> Direct link: [https://github.com/GitAlias/gitalias](https://github.com/GitAlias/gitalias)

</comment><comment><USER6> But you're still typing `git` every time!

        alias g=git

I've got my Git configs up at [https://github.com/kristjan/.dotfiles/blob/master/.gitconfig](https://github.com/kristjan/.dotfiles/blob/master/.gitconfig) if you'd like to sift through them. The very most common, like `git status`, get their own Bash aliases too ([https://github.com/kristjan/.dotfiles/blob/master/.aliases#L...](https://github.com/kristjan/.dotfiles/blob/master/.aliases#L37-L52)). Who can be bothered to type a space?

<comment><USER7> Not sure if I'm in the majority or minority here, but I actually prefer that the main command (git in this case) not be shortened. The rest of the options are where I find aliasing to be useful. Only because as the numbers of aliases you use grows, it becomes more likely that you'll overwrite your single-letter aliases.

<comment><USER6> Certainly everything in moderation - I only give letters to commands I literally type hundreds of times daily. Over the past 10 years, I've accumulated 5:

        b=`bundle exec`, though this is becoming less often used and I may remove it
        d=dotenv to easily wrap a command in environment variables
            (https://github.com/bkeepers/dotenv)
        g=git
        h=hub (GitHub's extensions to Git)
        j=autojump to move to common directories using just a few characters
            from their name (https://github.com/wting/autojump)

</comment></comment></comment><comment><USER8> Related: if you use Emacs, look into Magit, it's amazing.

[https://magit.vc/](https://magit.vc/)

<comment><AUTHOR> Thanks, I'm adding Magit to the README now.

</comment></comment><comment><USER9> aliases for opening files, which i find quite useful

      # open file by name
      op = "!f() { $(git editor) $(git ls-files | grep -i \"$@\"); }; f"

      # open currently edited (unstaged) files
      eop = "! $(git editor) $(git ls-files --modified)"

      # open files for conflicts (good for rebase/cherry-pick/merge)
      mop = "!f() { $(git editor) $(git diff --name-only --diff-filter=U); }; f"

      # open files present in diff
      dop = "!f() { $(git editor) $(git diff --name-only $@); }; f"

      # grep and open files containing
      gop = "!f(){ $(git editor) $(git grep --name-only \"$@\"); }; f"

      # "show and open" commit
      shop = "!f() { $(git editor) $(git show --pretty=\"format:\" --name-only $1); }; f"

      editor = config --get core.editor

I wrote a bit about them here: [https://wordpress.com/post/wuthefwasthat.wordpress.com/19](https://wordpress.com/post/wuthefwasthat.wordpress.com/19)

And all my aliases here: [https://github.com/WuTheFWasThat/dotfiles/blob/master/.gitco...](https://github.com/WuTheFWasThat/dotfiles/blob/master/.gitconfig)

<comment><USER10> That looks like some sort of internal WordPress link. I think you mean:

[https://wuthefwasthat.wordpress.com/2016/06/18/git-open- alia...](https://wuthefwasthat.wordpress.com/2016/06/18/git-open-aliases/)

</comment></comment><comment><USER11>
        c = checkout
        d = diff
        ds = diff --staged
        l = log --all --graph --oneline --decorate
        s = status --short --branch
        g = grep --break --heading --line-number
        ff = merge --ff-only
        puff = pull --ff-only
        purr = pull --rebase
        mnc = merge --no-ff --no-commit
        ignore = update-index --assume-unchanged
        unignore = update-index --no-assume-unchanged
        ignored = !git ls-files -v | grep '^[[:lower:]]'

</comment><comment><USER12> Hey, nice usage of "$(git branch-name)" in the commands, I haven't thought about that

I have been keeping my gitconfig public [1] it's been a while and I will definitely use this repo as another source to increment it :)

[1] [https://gist.github.com/felipesabino/6391408](https://gist.github.com/felipesabino/6391408)

<comment><AUTHOR> Thank you! I'm adding your link to the README now.

</comment></comment><comment><USER13> How can you justify mapping 'p' to 'pull' rather than 'push'?

I applaud the effort and think it's unfortunate the value add seems so marginal here. This type of thing boils down to mostly personal preference.

<comment><AUTHOR> I polled several hundred people during three years. :)

In practice, my teams tend to get the most value-add by using purpose-driven aliases for typical pull/push needs.

For example, the alias `publish` will push a local topic branch up to a continuous delivery server.

</comment></comment><comment><USER14> I'm personally a big fan of SCM Breeze[0]

[0] [https://github.com/ndbroadbent/scm_breeze](https://github.com/ndbroadbent/scm_breeze)

<comment><AUTHOR> Cool, thanks, I'm adding that to the README now.

</comment></comment><comment><USER15> I've got more insane and effective solution: [https://github.com/seletskiy/zsh-context- aliases](https://github.com/seletskiy/zsh-context-aliases)

So, aliases will change depending on the directory you're in.

And, instead of typing `g s` or `gs` to get `git status` you simply typing `s`.

</comment><comment><USER16> My favorite:

        unfuck = reset HEAD --hard

<comment><AUTHOR> Ha! That's hilarious. I'll add something like that, with slightly more polite language. :)

</comment></comment><comment><USER17> DUDE! Just link the github URL directly next time -- not only should this sort of discussion be done and persist on GH, not a random HN comment thread, but, for whatever reason, iOS won't let me copy that link so I have to type it in manually. Which I won't do.

Poor form, buddy. Poor form.</comment>


Octi launches social network built on AR and facial identification - <AUTHOR> https://techcrunch.com/2020/01/22/octi-social-network-launch/ <comment><USER2> While the tech may be impressive, this seems so creepy that I doubt it will catch on.</comment>


Unrequited Love - <AUTHOR> http://steveblank.com/2012/07/24/unrequited-love/ <comment><USER2> I've seen people take this lesson too serious and too lightly.

One was a company that refused to ever be accused of requited love. They would look for any excuse whatsoever to decide the other party "wasn't serious." A number of partnerships and buyouts passed them out until they had to be sold in an emergency, and they still acted like everything was totally out of their control up to the end.

And I've also seen lots of "partnerships" where one party really doesn't care at all.

You need to be willing to get rejected, but get rejected fast.

</comment><comment><AUTHOR> The more customers or partners pay when funding a custom development or implementing a solution, the more interest they will have to make it succeed. If only not to look like an idiot to their boss or management peers. Whereas if something is 'free' it can be quietly swept under the rug much easily.

</comment><comment><USER3> I wonder how much of this story directly relates to customers though. Free Trials, do enable questioning customers to come onboard. But at the same time, customers may not be "invested" enough to care to really evaluate your product.

However, how does one determine at which point the customer has invested enough? If I pay a dollar for an app on the appstore, I'm not nearly as invested in it as spending $30 or more.

I feel like I'm in a similar place with my product. It's meant for businesses, but the rational side of me wants to make it a freemium model so the maximum number of people get to know how awesome it is. On the other hand many business owners may not be taking my product as a serious contender as it's free.

</comment><comment><USER4> This is a good and relevant article based upon my experience (last company was SaaS company with 60% of revenue from partners). I would add that partners generally won't care much about your business (they care about their's, rightfully so) but when they decide to care (e.g., if a customer asks them for integration with you), you need to be top of mind and easy to work with. This is why I'm a huge fan of thinking of partners like customers - using drip marketing techniques to continue to stay on their radar, making partner content really easily available online (videos, etc.), giving them self- service options and so on.

</comment><comment><USER5> This is one of the best things I've read on HN in some time. (And, to add to the effect, it's pithy and makes its point quickly.)

</comment><comment><USER6> What ever happened to Onyx, btw?</comment>


Lua and Typesafety = Sol - <AUTHOR> https://github.com/emilk/sol <comment><USER2> Ironically, one of Lua's direct ancestors was SOL (Simple Object Language). I guess we've come full circle.

</comment><comment><USER3> There's also Typed Lua: [https://github.com/andremm/typedlua](https://github.com/andremm/typedlua)

The lead author gave a good presentation at Lua Workshop 2017 in SF: [https://www.lua.org/wshop17/Maidl.pdf](https://www.lua.org/wshop17/Maidl.pdf)

Both Sol and Typed Lua are no longer maintained. The Typed Lua author is working on a statically compiled cousin to Lua: [https://github.com/titan- lang/titan](https://github.com/titan-lang/titan)

I haven't used Sol or Typed Lua (too lazy), but I use the Typed Lua syntax for my recent API documentation as it reads well and allows me to minimally document an API before I get around to adding proper descriptions.

<comment><AUTHOR> Titan looks great! But it seems far from being usable.</comment></comment>


Ask HN: What are the most common reasons you fire an employee? - <AUTHOR> <comment><USER2> We've got a typical turnaround but rarely ever find the need to fire someone. I suspect that's the case for many other IT companies. There are simply so many other options available for developers, and if someone is not happy, they'll gladly just leave.

</comment><comment><USER3> The longer your career the more you see people's employment being terminated for a variety of reasons.

I'd say the primary reasons I have had to let people go (not in any specific order) are:

1\. Repetitive performance issues, and the inability to find them a good home in the company where they would succeed.

2\. Poor Attitude or bad team fit.

3\. Inability for the person to grow with the organization which typically leads to being a bad team fit as the company grows.

4\. Lack of funds

</comment><comment><USER4> Hopefully "Spending too much time on HN" doesn't make the list.

</comment><comment><USER5> When he fails the performance review with a bad vote. Probably he doesn't work at an high level or he has some relationship problem that makes difficult for him to work in a good team.

</comment><comment><USER6> I never fired anyone, but I expect the most common reason would simply be restructuring of an organisation, changing needs of the employer, and not so much anything the employee did.</comment>


Is a round Minecraft world possible? [video] - <AUTHOR> https://www.youtube.com/watch?v=ztAg643gJBA <comment><USER2> Interesting. But the video title is a bit mis-leading. It modifies minetest, a "free, open source voxel game engine" [1], not Minecraft.

\- [1] [http://www.minetest.net/](http://www.minetest.net/)

</comment><comment><USER3> Impressive. tl;dr it's possible to map a world made of squares into a torus in order to make it round. But I'm still really interested how the perspective was created of a spherical world although the mapping is toroidal.

<comment><USER4> I think he answers your question in this video: [https://www.youtube.com/watch?v=joFWr3JzBOI](https://www.youtube.com/watch?v=joFWr3JzBOI)

</comment></comment><comment><USER5> This is really cool!</comment>


Launch HN: Dataform (YC W18) – Build Reliable SQL Data Pipelines as a Team - <AUTHOR> Hi HN!
We're Guillaume and Lewis, founders of Dataform, and we're excited (and nervous) to be posting this on HN.
Dataform is a platform for data analysts to manage data workflows in cloud data warehouses such as Google BigQuery, Amazon Redshift or Snowflake. With our open source framework and our web app, analysts can develop and schedule reliable pipelines to turn raw data into reliable datasets they need for analytics.
Before starting Dataform, we managed engineering teams in AdSense and led product analytics for publisher ads. We heavily relied on data (and data pipelines!) to generate insights, drive better decisions and build better products. Companies like Google invest a lot to build internal data tools for analysts to manage data and build data pipelines. In 5 minutes I could define a new dataset in SQL that would be updated every day and then use it in my reports.
Most businesses today are centralising their raw data into cloud data warehouses but lack the tools to manage it efficiently. Pipelines run manually or via custom scripts that break often. Or the company decides to invest engineering resources to set up, maintain and debug a framework like Airflow. But that's just for scheduling and the technical bar is often too high for analysts to contribute.
We saw a need for a self-service solution for data teams to manage data efficiently, so that analysts can own the entire workflow from raw data to analytics. We built Dataform with two core principles in mind:
1. Bring engineering best practices to data management.
In Dataform, you build data pipelines in SQL, and our open source framework lets you seamlessly define dependencies, build incremental tables and reuse code across scripts. You can write tests against your raw and transformed data to ensure data quality across your analytics. Lastly, our development environment also facilitates the adoption of best practices, where analysts can develop with version control, code review or sandboxed environments.
2. Let data teams focus on data, not infrastructure.
We want to bring a better, faster and cheaper alternative to what businesses have to build and maintain in-house today. Our web app comes with a collaborative SQL editor, where teams develop and push their changes to GitHub. You can then orchestrate your data pipelines without having to maintain any infrastructure.
Here's is a short video demo where we develop two new datasets, push the code to GitHub and schedule their execution, in under 5 minutes.
https://www.youtube.com/watch?v=axDKf0_FhYU
You can sign up at https://dataform.co. If you're curious how it works - here are the docs: https://docs.dataform.co and the link to our open framework: https://github.com/dataform-co/dataform
We would love to hear your feedback and answer any questions you might have!
Lewis and Guillaume <comment><USER2> I take it everything is based on schedules, there's no runtime magic to handle incremental updates in a timely or efficient way? I've been watching @frankmcsherry's Materialize.io with interest, for example.

<comment><USER3> Possibly controversial, but I don't believe there are that many situations in data analytics where you really need realtime/streaming analytics. It usually comes at the cost of significant additional complexity and maintenance, that ultimately hurts reproducibility and agility.

Having said that, we are working on triggering table builds from watching changes to consumed data sets, which paired with an incremental table build would allow you to reliably achieve latency of under a few minutes.

<comment><USER4> I disagree.

Near realtime (say sub 1-minute) feeds can be leveraged to extract a lot of value out of the data you're collecting. Perhaps maybe not for your typical SaaS startup, but for free-to-play video games you end up leaving so much value on the table if you can't quickly (automatically) respond to spend or churn indicators.

I think a good rule of thumb for this is looking at how fast your decisions are made. If you're making decisions daily then refreshing your data every 24 hours is probably good enough. If you're making decisions every hour, then every 60 minutes is probably good enough.

Another factor is scale. When you're dealing with 6-figure CCUs and are trying to optimize conversion or retention through split-testing, figuring out which variants are anomalously poorly performing quickly can save you a whole lot of money.

I reckon there's at least a 50 titles that can benefit from streaming analytics, which immediately affects anywhere from 100-500 employees (analysts, engineers) and likely influences over 1000 (broader company). That's a significant portion of the field.

<comment><USER5> That's why I don't like the term real time. Decision time should be the criterion.

</comment></comment></comment></comment><comment><USER6> 1\. What do you think of NoETL and SQL++? Ref: [https://www.couchbase.com/products/analytics](https://www.couchbase.com/products/analytics)

2\. Do you think adopting a tool like Dataform makes more sense at mid-stage companies? Ref: [https://thinkgrowth.org/the-startup-founders-guide-to- analyt...](https://thinkgrowth.org/the-startup-founders-guide-to- analytics-1d2176f20ac1)

<comment><AUTHOR> 1\. I think NoETL products are complementary solutions. NoETL can be a great option for ad hoc queries and when performing a one-off analysis.

But for your company's analytics, you want to build a suite of well defined, reliable and documented datasets that power you dashboards and your regular analytics.

Another way to say it is that with NoETL, you write one query to answer one complex question. With ETL (actually ELT), you define core datasets with which you can answer many questions.

2\. In terms of adoption, products like Dataform are helpful from the day you start having data in your data warehouse and have a full time analyst. It's basically giving superpowers to your analysts.

<comment><USER6> _> well defined, reliable and documented datasets_

Can you elaborate this?

NoETL targets semi-structured and schema-less data models prevalent in NoSQL/HTAP data stores, so if well defined relates to well defined schemas, it maybe doesn't apply here.

As far as reliability (aka reproducibility) and documentation is concerned, I guess it's more about building tools that promote sound engineering processes like version control, modules (aka reusable snippets), documentation (could be Jupyter notebooks, etc.) and these tools could be built for NoETL systems too.

</comment></comment></comment><comment><USER7> Congrats on your launch! How is this different from DBT?

<comment><AUTHOR> Our framework (and the CLI interface) is pretty similar to be honest, except it's in JS. We also spent quite a bit of time focusing on performance.

The main difference is that we provide an all-in-one web platform for teams to develop, test and schedule their SQL pipelines. With one web interface and in 5 min, you can write a query, test it, add it to a schedule, push the changes to GitHub (or submit a PR) and monitor your jobs.

We make it easy to enforce software engineering best practices like version control and isolated deployments. For example, our version control works similarly to Looker. Analysts can work simultaneously from different branches while not having to use different tools nor use the command line.

<comment><USER7> What's the rationale behind using JS instead of Python/Jinja? Any insights on that?

<comment><USER3> Great question :)

1\. Speed. We wanted compilation to really, really fast. 2\. In all honesty we just weren't big fans of Jinja, having used it for quite a while. JS templating is OK out the box, and we are considering React like syntax in the future. 3\. Love it or hate it, NPM packages are pretty easy to work with and we are working on a number of packages at the moment. 4\. When you start to look at things like UDFs and Cloud functions which enables some really cool use cases, JS seems to be prevailing (in Snowflake and BigQuery at least).

I will admit though that we do usually get a bit of a shocked reply when people hear it's not Python!

<comment><USER7> I see your point but I think that data analysts are usually familiar with Python, not JS. The UI is cool and intuitive, it looks like you copied most of the concepts except Jinja from DBT. That's perfectly OK though, let's see where it goes!

</comment></comment></comment></comment></comment><comment><USER8> >In Dataform, you build data pipelines in SQL, and our open source framework lets you seamlessly define dependencies, build incremental tables and reuse code across scripts.

Do you have any plan to add a visual interface? Unfortunately many analysts I work with are not really capable in SQL, or don't fully grok SQL features.

Also, how you plan on creating a moat against cloud companies putting the functionality of your project in their own proprietary solutions? For example, in Azure you can already use the Azure Data Lake stack of ADL Storage + Analytics + Data Factory to do what you are doing. These have IDE integrations, CICD integrationos, git integrations, are first class citizens in their cloud interfaces, etc.

<comment><USER3> A UI for building data transformations (SQl queries) isn't on our immediate roadmap, but we have thought about it.

We are taking a bit of a bet here that the industry is moving towards SQL, and we see a growing interesting in analysts wanting to learn it.

Moat: Always a concern! Short term we think most of our unique value comes from the collaborative web development experience which is not OSS currently. Also staying platform agnostic is important to us. Longer term, we have some plans which without going into details mostly focuses on building value around a community and our SQL ecosystem, but not ready to get into details just yet.

</comment></comment><comment><USER9> Apart from being cloud-focused, what's the difference between dataform and a classic ETL engine like SQL Server Integration Services?

<comment><AUTHOR> Great question. Beyond being on the cloud and everything that goes with that, I'd say that there are two fundamental differences with a product like SSIS.

1\. Dataform focuses on transformations happening _inside_ the cloud data warehouse. We don't move data between systems. More and more businesses are moving from traditional ETL processes to ELT and centralising their raw data in their warehouse. Dataform help businesses manage the T in ELT.

2\. Dataform is built with software engineering best practices in mind. In Dataform, all your transformations are written in code (mostly SQL) instead of a GUI like SSIS. The code can be version controlled, edited and fits better the large amount of transformations teams have to deal with.

<comment><USER9> Is there a tutorial to run it on-prem? For example for development or testing purposes?

What data warehouses are currently and which are on the roadmap? Is ClickHouse somewhere in your plans?

<comment><USER3> On-prem: Right now our IDE is only available as SaaS, although we will be looking at this in the near future. You can develop and test projects with the CLI and deploy them yourself but no tutorials for setting this up beyond the basics yet: [https://docs.dataform.co/guides/command-line- interface/](https://docs.dataform.co/guides/command-line-interface/)

Warehouse support: Athena/Presto and Azure are top of mind. I've not come across ClickHouse before but I'll definitely add it to our tracker!

</comment></comment></comment></comment><comment><USER10> What's the core transformation technology running the SQL transforms? Are you relying on the cloud data warehouse itself (i.e. BigQuery, Amazon Redshift or Snowflake) to run the SQL transforms? Asking because the transform workload usually dominates the query workload if they're not properly separated.

<comment><USER11> Just from the docs, it appears to rely on the warehouse itself. It's basically SQL + js templates make data engineers/analysts jobs easier.

<comment><USER3> Yup, the warehouse or query engine does the heavy lifting, we do the orchestration and make easier to develop these pipelines.

</comment></comment></comment><comment><USER12> Any success getting through the VRM process at a financial services firm? Your product looks very exciting.

<comment><AUTHOR> Thank you! We haven't been through VRM yet but that's about to come up. If you have any tips, would love to hear your thoughts. I am at ghh@[domain]

</comment></comment><comment><USER13> Does it work cross databases? Ie, if data is stored in multiple databases and needs to be combined for analytics? Currently, we are getting all data to S3 via DMS and running a script on top of this to combine data

<comment><USER3> Dataform still requires you to move your data to a single place where it can be queried together, whether that's S3 with Presto, Redshift spectrum, or something else.

There are lots of great products for moving data like this, Stitch, Fivetran are both great and we've used them ourselves, but they don't help you manage complex data transformation processes.

</comment></comment><comment><USER14> Looks like yet another ETL/ELT tool.

We have been using composable with quite a bit of success: [https://dev.composable.ai](https://dev.composable.ai)

<comment><AUTHOR> Indeed. Dataform however only does the T (transformation) in ELT. Most businesses are centralising an exploding diversity of raw data in the data warehouse and Dataform helps them manage the data there.

One other main difference with a product like composable is that Dataform is built with software engineering best practices in mind. The transformations are written in code (SQL) rather than a GUI. It enables version control, reusable components for example and makes it easier to manage a large number of interdependent transformations.

<comment><USER15> To be fair, these other tools do this as well.

</comment></comment></comment><comment><USER16> Does this add any value beyond what PDTs in Looker provide?

<comment><AUTHOR> Definitely!

We see that PDT doesn't scale well with the the amount of data complexity you usually have to deal with in the warehouse.

On top of that, the results of PDTs are only accessible to Looker. As your data team matures, there will be many other users and applications that need to take advantage of your transformed data in the warehouse. (e.g. modelling in Python)

Dataform also brings other features not available in PDTs. For example:

\- Data validations tests (assertions) to ensure data quality in all your data applications (including Looker)

\- Incremental tables: You can define tables that update incrementally instead of being rebuilt from scratch, hence delivering better performance and saving costs

\- Reusable code. You can define reusable code snippets across your entire project

<comment><USER17> I much agree with this response. The term that I've heard to summarize all of the above is "semantic layer". That layer will run in the warehouse, vs. some external dashboard tool.

</comment></comment></comment><comment><USER18> Is there a roadmap for adding other data sources?

<comment><USER3> CTO here, What are you after? :)

Athena/Presto, Azure are next in our sights.</comment></comment>


Docker 0.8: Quality, new builder features, btrfs, OSX support - <AUTHOR> http://blog.docker.io/2014/02/docker-0-8-quality-new-builder-features-btrfs-storage-osx-support/

<comment><USER3> Just to clarify on the OSX support: obviously we did not magically get Darwin to support linux containers. But we put together the easiest possible way to run Linux containers on a Mac without depending on another machine.

We do this by combining (1) docker in "client mode", which connects to (2) a super-lightweight linux VM using boot2docker.

The details are on [http://docs.docker.io/en/latest/installation/mac/](http://docs.docker.io/en/latest/installation/mac/)

<comment><USER4> Too bad it depends on VirtualBox - had a lot of kernel panics when using it, so I decided to stick with VMware fusion.

<comment><USER5> Are you sure it isn't caused by the mid-2010 macbook video card bug? I had it re-exposed when i upgraded past 10.6 and that laptop now reboots 8 times a day. Mostly from mac mail or when the power drops and it shifts video cards.

<comment><USER6> FWIW, I had my 2010 mbp motherboard warranty-replaced and the crashes were gone.

<comment><USER7> Mine started failing a few months outside the replacement period (3 years). I was due for a new work laptop, so I just replaced the machine.

</comment></comment></comment></comment></comment><comment><USER8> Was the OS X binary built without cgo? I can't seem to access containers in private https registries:

        $ docker login https://registry.example.com
        2014/02/05 14:36:20 Invalid Registry endpoint: Get https://registry.example.com/v1/_ping: x509: failed to load system roots and no roots provided

The hostname in question has a valid SSL certificate. I encountered a similar problem in the past with Go built from homebrew[1][2]. Has anyone else seen this?

[1] [https://github.com/Homebrew/homebrew/pull/17758](https://github.com/Homebrew/homebrew/pull/17758) [2] [https://code.google.com/p/go/issues/detail?id=4791](https://code.google.com/p/go/issues/detail?id=4791)

Update: Filed a bug against docker, others are having the same issue. [https://github.com/dotcloud/docker/issues/3946](https://github.com/dotcloud/docker/issues/3946)

<comment><USER9> Thanks for the report. We are working on a fix ASAP and will post updates on [https://github.com/dotcloud/docker/issues/3683](https://github.com/dotcloud/docker/issues/3683).

<comment><USER10> In the meantime, if you need to get it working right now, you can build your own binary as outlined here: [http://blog.devtable.com/2014/01/using-docker- on-osx-with-pr...](http://blog.devtable.com/2014/01/using-docker-on-osx-with- private.html)

We've confirmed the instructions still work with Docker 0.8 (make sure to change the checkout branch though :))

</comment></comment></comment><comment><USER11> Glad to hear OS X has official support. I jumped into Docker for the first time last week and have a burning unresolved question for those using boot2docker.

What is your development workflow? I am working on a Rails app, so my instinct is to have a shared folder between OS X and boot2docker, but afaik this is not supported as boot2docker doesn't support VirtualBox guest extensions.

<comment><USER3> Hi Matt, you are not alone :)

It turns out that shared folders are not a sustainable solution (independently of whether boot2docker supports them), so the best practices are converging towards this:

1) While developing, your dev environment (including the source code and method for fetching it) should live in a container. This container could be as simple as a shell box with git and ssh installed, where you keep a terminal open and run your unit tests etc.

2) To access your source code on your host machine (eg. for editing on your mac), export it from your container over a network filesystem: samba, nfs or 9p are popular examples. Then mount that from your mac. Samba can be natively mounted with "command-K". NFS and 9p require macfuse.

3) When building the final container for integration tests, staging and production, go through the full Dockerfile + 'docker build' process. 'docker build' on your mac will transparently upload the source over the docker remote API as needed.

There are several advantages to exporting the source from the container to the host, instead of the other way around:

\- It's less infrastructure-specific. If you move from virtualbox to vmware, or get a Linux laptop and run docker straight on the metal, your storage/shared folders configuration doesn't change: all you need is a network connection to the container.

\- Network filesystems are more reliable than shared folders + bind-mount. For example they can handle different permissions and ownership on both ends - <USER2> very common problem with shared folders is "oops the container creates files as root but I don't have root on my mac", or "apache complains that the permissions are all wrong because virtualbox shared folders threw up on me".

That said, we need to take that design insight and turn it into a polished user experience - hopefully in Docker 0.9 this will all be much more seamless!

<comment><USER12> Thanks for taking the time to write this. I've hit a major wall in figuring out the best workflow for this exact scenario. Good to finally hear an official suggestion on the matter. I've been depending on shared directories, so I'll definitely be experimenting with network filesystems.

As Docker evolves, it would be great to have some kind of official resource to get suggestions for optimal workflows as new features become available (the weekly docker email is my best resource right now). Searching the internet for info has been a huge chore as most of the resources (including the ones hosted by docker.io) are woefully out of date.

<comment><USER3> > _As Docker evolves, it would be great to have some kind of official resource > to get suggestions for optimal workflows as new features become available_

Yes! We are trying to figure this out. Our current avenue for this is to dedicate a new section in the docs to use cases and best practices.

As you point out, our docs (and written content in general) are often inaccurate. We need to fix this. Hopefully in the coming weeks you will start seeing notable improvements in these areas.

Thanks for bearing with us!

</comment></comment></comment></comment><comment><USER13> Is Docker a good way to bring more security on a server with a few different websites? Separating the sites from each other and run nginx as a proxy in front of them?

What's the overhead?

<comment><USER14> Unfortunately Docker prevents hosting environments from employing some of the most potent security mitigations added to Linux recently.

You cannot treat a docker container like a virtual machine – code running in the container has almost unfettered access to the parent kernel, and the millions of lines of often-buggy C that involves. For example with the right kernel configuration, this approach leaves the parent machine vulnerable to the recent x86_32 vulnerability ([http://seclists.org/oss- sec/2014/q1/187](http://seclists.org/oss-sec/2014/q1/187)) and many similar bugs in its class.

The algorithms in the running kernel are far more exposed too - instead of managing a single process+virtual network+memory area, all the child's resources are represented concretely in the host kernel, including its filesystem. For example, this vastly increases the likelihood that a child could trigger an unpatched DoS in the host, e.g. the directory hashing attacks that have effected nearly every filesystem implementation at some point (including btrfs as recently as 2012).

The containers code in Linux is also so new that trivial security bugs are being found in it all the time – particularly in sysfs and procfs. I don't have a link right now, though LWN wrote about one a few weeks back.

While virtual machines are no security panacea, they diverge in what classes of bugs they can be affected by. Recent Qemu/libvirt supports running under seccomp.. ensuring even if the VM emulator is compromised, the host kernel's exposure remains drastically limited. Unlike qemu, you simply can't apply seccomp to a container without massively reducing its usefulness, or using a seccomp policy so liberal that it becomes impotent.

You could use seccomp with Docker by nesting it within a VM, but at that point Docker loses most of its value (and could be trivially replaced by a shell script with a cute UI).

Finally when a bug is discovered and needs to be patched, or a machine needs to be taken out of service, there is presently no easy way to live-migrate a container to another machine. The most recent attempt (out of I think 3 or 4 now) to add this ability to Linux appears to have stalled completely.

As a neat system for managing dev environments locally, it sounds great. As a boundary between mutually untrusted pieces of code, there are far better solutions, especially when the material difference in approaches amounts to a few seconds of your life at best, and somewhere south of 100mb in RAM.

<comment><USER3> > _Unfortunately Docker prevents hosting environments from employing some of > the most potent security mitigations added to Linux recently._

You list various facts that are mostly correct, but your conclusion is wrong. Docker absolutely _does not_ reduce the range of security mitigations available to you.

Your mistake is to present docker as an alternative to those security mitigations. It's not an alternative - it presents you with a sane default which can get you pretty far (definitely further than you are implying). When the default does not fit your needs, you can fit Docker in a security apparatus that does.

The current default used by docker is basically pivot_root + namespaces + cgroups + capdrop, via the lxc scripts and a sane locked down configuration. Combined with a few extra measures like, say, apparmor confinement, dropping privileges inside the container with `docker run -u`, and healthy monitoring, you get an environment that is production-worthy for a large class of payloads out there. It's basically how Dotcloud, Heroku and almost every public "paas" service out there works. It's definitely not a good environment for _all_ payloads - but like I said, it is definitely more robust than you imply.

So your first mistake is to dismiss the fact that linux containers are in fact an acceptable sandboxing mechanism for many payloads out there.

Your second mistake is to assume that if your payloads need something other than linux containers, you can't use Docker. Specifically:

> _You cannot treat a docker container like a virtual machine – code running > in the container has almost unfettered access to the parent kernel, and the > millions of lines of often-buggy C that involves. For example with the right > kernel configuration, this approach leaves the parent machine vulnerable to > the recent x86_32 vulnerability ([http://seclists.org/oss- > sec/2014/q1/187](http://seclists.org/oss-sec/2014/q1/187)) and many similar > bugs in its class._

> _The containers code in Linux is also so new that trivial security bugs are > being found in it all the time – particularly in sysfs and procfs. I don 't > have a link right now, though LWN wrote about one a few weeks back._

> _While virtual machines are no security panacea, they diverge in what > classes of bugs they can be affected by. Recent Qemu /libvirt supports > running under seccomp.. ensuring even if the VM emulator is compromised, the > host kernel's exposure remains drastically limited. Unlike qemu, you simply > can't apply seccomp to a container without massively reducing its > usefulness, or using a seccomp policy so liberal that it becomes impotent._

Of course you're right, sometimes a container is not enough for sandboxing and you need a VM. Sometimes even a VM is not enough and you need physical machines. That's fine. Just install docker on all of the above, and map containers to the underlying machines in a way that is consistent with your security policy. Problem solved.

> _You could use seccomp with Docker by nesting it within a VM, but at that > point Docker loses most of its value (and could be trivially replaced by a > shell script with a cute UI)._

That's your judgement to make, but I'm going to go a whim and say that you haven't actually used Docker that much :) Docker is commonly used in combination of VMs for security, so at least _some_ people find it useful.

> Finally when a bug is discovered and needs to be patched, or a machine needs > to be taken out of service, there is presently no easy way to live-migrate a > container to another machine. The most recent attempt (out of I think 3 or 4 > now) to add this ability to Linux appears to have stalled completely.

In my opinion live migration is a nice to have. Sure, for some payloads it is critically needed, and no doubt the day linux containers support full migration those payloads will become more portable. But in practice a very large number of payloads don't need it, because they have built-in redundancy and failover at the service level. So an individual node can be brought down for maintenance without affecting the service as a whole. Live migration also has other issues, for example it doesn't work well beyond the boundaries of your shared storage infrastructure. Good luck implementing live migration across multiple geographical regions! This has been established as ops best practices , so over time the number of payloads which depend on live migration will diminish.

> _As a neat system for managing dev environments locally, it sounds great. As > a boundary between mutually untrusted pieces of code, there are far better > solutions, especially when the material difference in approaches amounts to > a few seconds of your life at best, and somewhere south of 100mb in RAM._

To summarize: docker is primarily a system for managing and distributing repeatable execution environments, _from development to production_ (and not just for development as you imply). It does not implement any security features by itself, but allows you to use your preferred isolation method (namespaes, hypervisor or good old physical separation) without losing the benefits of repeatable execution environments and a unified management API.

<comment><USER14> Look, I'm really glad that you're excited for docker, but name dropping companies running the risk of exposing their machines does not magically invalidate the specific examples I gave. In fact I've really no idea what purpose your reply was hoping to serve.

In the default configuration (and according to all docs I've seen), regardless of some imagined rosy future, _today_ docker is a wrapper around Linux containers, and Linux containers _today_ are a very poor general purpose security solution, especially for the kind of person who needs to ask the question in the first place (see also: the comment I was originally replying to)

<comment><USER3> > _name dropping companies running the risk of exposing their machines does > not magically invalidate the specific examples I gave_

You're right. But what it does is provide anecdotical evidence that your views are not shared by a large and growing number of experienced engineers.

> _In fact I 've really no idea what purpose your reply was hoping to serve._

It's pretty simple: you made an incorrect statement, I'm offering a detailed argument explaining why.

> _In the default configuration (and according to all docs I 've seen) [...] > today docker is a wrapper around Linux containers_

Yes.

> _[...] regardless of some imagined rosy future [...]_

I only described things that are possible today, with current versions of Docker. No imagined rosy future involved :)

> _and Linux containers today are a very poor general purpose security > solution_

I guess it really depends of your definition of "general purpose", so you could make a compelling argument either way.

But it doesn't matter because if you don't trust containers for security, you can just install Docker on a bunch of machines and make sure to deploy mutually untrusted containers on separate machines. Lots of people do this today and it works just fine.

In other words, Docker _can_ be used for deployment and distribution without reducing your options for security. Respectfully, this directly contradicts your original comment.

<comment><USER15> > But it doesn't matter because if you don't trust containers for security, > you can just install Docker on a bunch of machines and make sure to deploy > mutually untrusted containers on separate machines. Lots of people do this > today and it works just fine.

> In other words, Docker can be used for deployment and distribution without > reducing your options for security. Respectfully, this directly contradicts > your original comment.

If I understand services like Heroku correctly, they give customers standard access to run arbitrary code inside a container as a standard user. Therefore, I expect it would be standard and unavoidable to have many different customers' applications running on the same machine, leading to the ability to exploit vulnerabilities similar to the recent x32 one. If they instead used a VM for each application, they would have to pierce the VM implementation, potentially plus seccomp in some cases, which is the mitigation the parent was referring to. The choice to use Docker instead of VMs limits the security options available.

<comment><USER16> >> In other words, Docker can be used for deployment and distribution without reducing your options for security. Respectfully, this directly contradicts your original comment.

>If they instead used a VM for each application, they would have to pierce the VM implementation, potentially plus seccomp in some cases, which is the mitigation the parent was referring to. The choice to use Docker instead of VMs limits the security options available.

The parent is suggesting you can use Docker as a supplement to _any_ additional security measure one might choose (to quote: "Docker is commonly used in combination of VMs for security, so at least some people find it useful").

In your example, a person would run Docker on top of the VM, and gain "a system for managing and distributing repeatable execution environments".

</comment></comment></comment></comment></comment></comment></comment><comment><USER17> So what's the solution for 'root inside a docker container is root on the host'?

We'd like to ship a set of utilities as a docker container, but unless the sysadmin gives everyone 'sudo' privileges on the server (unlikely and insecure), they can't run the container and its utilities.

Any advice?

<comment><USER3> Look for an update on this in 0.9 :)

Future versions of the Docker API will natively support _scoping_. This means that each API client will see a different subset of the Docker engine depending on the credentials and origin of the connection. This will be implemented in combination with _introspection_ , which allows any container to open a connection to the Docker engine which started it.

When you combine _scoping_ and _introspection_ , you get really cool scenarios. For example, let's say your utility is called "dockermeister". Each individual user could deploy his own copy of dockermeister, in a separate container. Each dockermeister container would in turn connect to Docker (via _introspection_ ), destroy all existing containers, and create 10 fresh redis containers (for reasons unknown). Because each dockermeister container is _scoped_ , it can only remove containers that are its children (ie that were created from the same container at an earlier time). So they cannot affect each other. Likewise, the 10 new redis containers will only be visible to that particular user, and not pollute the namespace of the other users.

Of course scoping works at arbitrary depth levels... so you could have containers starting containers starting containers. Containers all the way down :)

</comment></comment><comment><USER18> Awesome that OSX support is now official, but is there any benefit to using this process as opposed to using docker-osx? [https://github.com/noplay/docker-osx](https://github.com/noplay/docker-osx)

The official installation process seems more complicated, and I don't really see an advantage.

</comment><comment><USER19> I'm curious about how the focus on multiple, ABI-incompatible platforms will affect the pace and momentum of Docker development. So far, Docker has benefitted a lot from the focus on amd64 userland on Linux.

<comment><USER20> Personally, when I read "OSX support", I thought that meant that there would now be containers with Darwin-ABI binaries inside them. So on Linux, you'd use cgroups for Linux-ABI binaries and a VM for Darwin-ABI, just as on OSX you use a VM for Linux-ABI (and presumably would use the OSX sandbox API for Darwin- ABI containers.)

This "native sandboxing for own-ABI if available, VM if not, and VM for everything else" approach would extend to any other platform as well, I'd think (Windows, for example.) I'm surprised that this _isn 't_ where Docker is going, at least for development and testing of containers.

(Though another alternative, probably more performant for production, would be something like having versions of CoreOS for each platform--CoreOS/Linux, CoreOS/Darwin, CoreOS/NT, and so on--so you'd have a cluster of machines with various ABIs, where any container you want to run gets shipped off to a machine in the cluster with the right ABI for it.)

<comment><USER21> Going that way would dilute Docker's value. Docker's promise is that you can build a container and it will always work; it won't mysteriously break in production or giving you installation headaches. To do that, your development environment has to be as close to the production environment as possible. Having a totally different ABI doesn't help with that goal.

<comment><USER3> Our priority in the short term is definitely to focus on the Linux ABI and making it available on as many physical machines as possible. This is the reasoning behind our current OSX support, and support for more platforms coming soon.

Longer term we do need to support multiple ABIs, if only because a lot of people want to use Docker on x86-32 and ARM. Having ELF binaries built on Linux isn't of much help if they're built for another arch :) So at the very least we will need to support 3 ABIs in the near future.

The good news is that it can be done in a way which doesn't hurt the repeatability of Docker's execution environment. Think of it this way: every container has certain requirements to run. At the very least it needs a certain range of kernels and archs (and yes it's possible, although uncommon for a binary to support multiple archs). It may also require a network interface to bind a socket on a certain TCP port. It may require certain syscalls to be authorized. It may require the ability to create a tun/tap device. And so on.

Docker's job is to offer a portable abstraction for these requirements, so that the container can list what it needs on the one hand, the host can list what it offers on the other, and docker can match them in the middle. If the requirements listed by a given container aren't met ("I need CAP_SYSADMIN on a 3.8 linux kernel and an ARM processor!") then docker returns an error and a clear error message. If they _are_ met, the container is executed and _must always be repeatable_.

TLDR: ABI requirements are just one kind of requirements. Docker can handle multiple requirements without breaking the repeatability of its execution environment.

<comment><USER22> Your reply primarily addresses architecture support and the implications for pre-built payloads. But I think a more important concern is the fragmentation that would result if Docker attempted to natively support other operating systems. Consider that practically every Dockerfile starts with a Linux distro, and includes commands specific to that distro (e.g. installing packages with apt). Everybody assumes that the payload is Linux-based, and it all just works. How would it work if Docker also supported FreeBSD jails, Illumos zones, or whatever other options are up for consideration? Would the public registry of Docker images now be fragmented along OS lines? Or would Docker try to automagically smooth over the fragmentation by firing up VMs when the host and container operating systems don't match? In the latter case, would every Docker installation then require a working hypervisor?

Considering that the overwhelming majority of Unix servers are running Linux, I think it's better to say that Docker is Linux-based, end of discussion.

<comment><USER21> I think what he's saying is that although Docker will support other Linux ABIs, it will stay with Linux.

</comment></comment></comment></comment></comment></comment><comment><USER23> Note that you need to be running boot2docker 0.5.2 [1] (with docker 0.8) for docker to work properly on OS X.

[1] [https://github.com/steeve/boot2docker/releases/tag/v0.5.2](https://github.com/steeve/boot2docker/releases/tag/v0.5.2)

</comment><comment><USER24> IMO, it would be fantastic if there was something like Docker for Windows. Imagine being able to bundle up games in individual containers and easily being able to move them from machine to machine as you upgrade. Same thing applies for other Windows apps.

<comment><USER25> Docker is to Unix almost as Microsoft App-V/VMware ThinApp/Symantec Workspace Virtualization products are to Windows.

Not exactly the same but closer.

<comment><USER24> Precisely, it's not the same. There still a whole bunch of fiddling going on.

I'll stick to my statement. I want something Docker-like for Windows so that I can easily move things from one machine to another.

<comment><USER25> It seems like they are working on it: "Microsoft Corporation : Patent Issued for Extensible Application Virtualization Subsystems" [http://www.4-traders.com/MICROSOFT- CORPORATION-4835/news/Mic...](http://www.4-traders.com/MICROSOFT- CORPORATION-4835/news/Microsoft-Corporation--Patent-Issued-for-Extensible- Application-Virtualization-Subsystems-17940954/)

</comment></comment></comment></comment><comment><USER26> I just tried the docker interactive tutorial. It was fun, but I still don't get the point of using docker. Just been hearing a lot about it, and its getting too much buzz.

</comment><comment><USER27> I am interested in the BTRFS support in particular, it is clear that performance in FS is key. However, what I like the most about Docker is the ability to use layers and diff them. In effect, I want version control for images, because it allows me to not run extra provisioning tools for the images (just rely on simply Zookeeper stuff for app config). Whatever gives me 'vcs' for images in the most performant way, wins in my book.

</comment><comment><USER28> It's confusing why btrfs support was prioritized ahead of zfs considering zfs' superior architecture and ops capabilities. Is docker (formerly dotcloud) going to start withholding capabilities as licensed features?

Edit: prelim zfs driver work is here [https://github.com/gurjeet/docker/tree/zfs_driver](https://github.com/gurjeet/docker/tree/zfs_driver)

<comment><USER29> What superior architecture does zfs have?

<comment><USER30> My understanding is that btrfs is still in catchup mode for the foreseeable future, but might _eventually_ cover the distance.

Has btrfs jumped ahead of zfs in ways I haven't heard about?

Edit - this is my first search result:

[http://rudd-o.com/linux-and-free-software/ways-in-which- zfs-...](http://rudd-o.com/linux-and-free-software/ways-in-which-zfs-is- better-than-btrfs)

<comment><USER28> I'd be biased to agree since that's Manuel's blog, someone I used to work with. I've supported 24x7 and 9x5 ops where downtime was unacceptable. zfs makes it a whole lot easier to perform upgrades, know data and metadata are solid and send snapshots around.

<comment><USER30> > ZFS uses atomic writes and barriers

This about settles the question for me. Assuming that the implication that btrfs performs otherwise holds true.

<comment><USER29> Barriers are also used in btrfs.

and from what i can tell clone operations are also handled atomically

though i kinda wonder what exactly is meant by atomic writes.

<comment><USER30> Thanks for clearing that up.

I might have to dig into it a bit more.

</comment></comment></comment></comment></comment></comment></comment><comment><USER31> It's not explicitly said, but are they following Semantic Versioning? [http://semver.org/](http://semver.org/)

<comment><USER32> Not exactly. The article says the first number is for major lifecycle events, ie 1.0 means "production ready". They'll be releasing monthly and the second number will be the release increment. The third number will be for patches and fixes.

So to me that doesn't fit in with the Semantic Versioning contract. I think the product is too young yet to use a version scheme that assumes relative API stability.

<comment><USER33> Well, to be fair, this is why even with semver 0.x means "anything goes". It's only from 1.x onwards that major version increments should be used for backwards-incompatible changes.

</comment></comment></comment><comment><USER34> Awesome release, especially since I can now use Docker on OS X without having to boot up a full Ubuntu VM through Vagrant.

If anyone else is using Boxen, I packaged up a quick Puppet module to get up and running with Docker on OS X: [https://github.com/morgante/puppet- docker](https://github.com/morgante/puppet-docker)

</comment><comment><USER35> why is osx support necessary on the path to 1.0? i'd rather have a simple, small, 1.0 release i can trust than all these "bells and whistles".

<comment><USER3> It's not necessary and we didn't go out of our way to get it. We just happened "for free" as a result of writing portable code, a clean client-server architecture and the appearance of the boot2docker project in the community.

</comment></comment><comment><USER36> Anyone using Docker on 32-bits?

<comment><USER37> Docker does not (yet) support 32-bit architectures.

<comment><USER36> I think I read that you just have to disable a condition somewhere and build your own base image or something like that.

</comment></comment></comment><comment><USER38> can someone explain what this is ? and what's the purpose ?

<comment><USER37> Try here: [http://www.docker.io/learn_more/](http://www.docker.io/learn_more/)

<comment><USER38> nope, I still don't get it.

> Docker is an open-source engine that automates the deployment of any > application as a lightweight, portable, self-sufficient container that will > run virtually anywhere.

Like an internet browser for executables ? I don't understand how can this be useful...

<comment><USER39> Containers are like virtual machines, only without the hardware emulation.

See [http://en.wikipedia.org/wiki/LXC](http://en.wikipedia.org/wiki/LXC)

See [http://docs.docker.io/en/latest/faq/#how-do-containers- compa...](http://docs.docker.io/en/latest/faq/#how-do-containers-compare-to- virtual-machines)

Docker is a mechanism to bundle an application together inside a container (think VM instance) in a way that makes it easier to distribute.</comment></comment></comment></comment>


HomePod Teardown - <AUTHOR> https://www.ifixit.com/Teardown/HomePod++Teardown/103133 <comment><USER2> Holy crap this is a mess. I'm assuming this is a 1/10 because their scale doesn't go down to 0.

$350 for a device you effectively cannot repair without ruining some part of it is absolutely astonishing. To anybody that says "so what?", if any part of this dies for whatever reason, not only are you almost completely out of your money, there's no way this thing is actually getting repaired by Apple. At best most of the components end up going through a recycler. At worst, that's 5lbs of added landfill.

Speakers are something that NEED to be repaired. It's one of the non-solid state technologies that we haven't found a better alternative for, and are some of the most fragile parts in systems today. These drivers/cones WILL wear out over time and the only thing you're going to be able to do is buy a new unit.

<comment><USER3> > Speakers are something that NEED to be repaired

Is that true? If there's one component that's stood the test of time in my home theater setup, it's been the speakers. I've purchased a ton of speakers in my time and I'm still rocking some 15 year old Kenwood speakers in the living room.

<comment><USER2> And that's fine, I have some Dick Sequerra MET-11's that have been around for many years before I was born and I only had to repair the tweeters two years ago. However these were high quality expensive speakers when they came out. Cheap drivers were not used. Looking at the HomePod and the processing hardware and their margins, there's no way the drivers they are putting in this thing are any better than what you'd find in a cheapo HTIB system.

The way I see it, these speakers are great for somebody that wants to remain in the Apple ecosystem and has $350 to drop on something that's going to be obsolete and incompatible in a few years. So yeah maybe these drivers won't need to be replaced, but that's only because the software driving them has a shorter life expectancy.

<comment><USER4> Indeed, as pointed out by the Accidental Tech podcast and others, even if the speakers hold up, what is going to kill it for longevity is the lack of a line-in. It is very unlikely that HomePod's version of AirPlay is going to be supported for more that 10 years. If the device had a line-in, it would still serve as a fine speaker beyond that. But now it is practically useless, even when you are in the Apple ecosystem, once Apple deprecates AirPlay 2.

In the meanwhile, I enjoyed the Altec Lansing speakers that my parents bought in the 70ies for quite some years.

(We were interested in the HomePod, but the lack of a line-in, and low- reparability has made the choice difficult. Added to that, I don't really like that it has so many Mics. 2025's Apple could be 2015's Lenovo, there is no guarantee that they will keep focusing on security & privacy, nor that they will resist government surveillance.)

<comment><USER5> Why do you assume that? AirPlay has been around for more than 10 years. You can still use a 15 year old AirPort Express with AirTunes the same exact way as when you bought it.

<comment><USER4> Except that you cannot configure it anymore unless you have an (insecure) Leopard or Snow Leopard machine on the same network [1]. Snow Leopard was released in 2009, the first generation Airport Express was sold 2004-2008 [2]. So Apple is not unwilling to axe support for a product rather quickly.

If they plan to support the latest AirPlay on the HomePod for 10 or 15 years, why not just state this? If you are not doing that, you want to keep the possibility to end support earlier.

[1] [https://support.apple.com/en-us/HT201519](https://support.apple.com/en- us/HT201519) [2] I know that you could install the old Airport Utility unofficially for a while.

</comment></comment></comment></comment></comment></comment><comment><USER6> Here's a little doc Vice did behind the scenes of iFixit

[https://www.youtube.com/watch?v=tx-9LkVIdz0](https://www.youtube.com/watch?v=tx-9LkVIdz0)

<comment><USER7> That was a really fun watch. Thanks for sharing!

</comment></comment><comment><USER8> For all the talk from Apple about recycling, they sure love to design disposable products. I say this as a HomePod owner.

<comment><USER9> Recycling generally refers to the component materials, not reuse of the finished product. That's why the green mantra is "reduce, reuse, recycle" (in preferential order).

<comment><USER8> Right, it refers to recycling the component materials AFTER I part with my laptop. But maybe I wouldn't have had to part with my laptop for another 4 years if the RAM wasn't soldered on. Thus overall reducing all the processing needed.

</comment></comment></comment><comment><USER10> Far more interesting

"Apple is operating at a 38 percent margin – which is significantly smaller than the margins on iPhone and Apple Watch.

For comparison's sake, Google sells its Google Home smart speaker at a 66 percent margin, while the Amazon Echo is sold at a 56 percent margin"

<comment><USER11> This is also the first generation of the device. These things tend to scale up.

<comment><USER10> Maybe. But I am surprised it came from Apple. It feels very unfinshed for an Apple product.

Just obvious things like a physical mic mute button for example.

The most surprising is doing features without the security yet available needed with the feature.

So no voice ID yet you can get text messages read back.

Been a long time Apple fan but honestly of late it is really hard to understand what is going on at Apple.

</comment></comment></comment><comment><USER12> The quality of this product aside, I want to comment on how great iFixIt is. With their guides, I've been doing my own phone repairs recently, which helps me keep my phone in working order for longer rather than buying a new one all the time. They're a great resource.

</comment><comment><USER13> It's pretty telling that one of the "Tools Featured in this Teardown" is a hacksaw.

</comment><comment><USER14> They give a Surface a 0/10 in repairability. They give the HomePod a 1/10.

They had to to use a hacksaw and knives on the HomePod.

What?

<comment><USER15> To be fair, when you send in a Surface for repair, they just send you a new unit because apparently even Microsoft can't repair the device!

<comment><USER16> Likely this applies to this device too, and I expect they reuse the internals for new devices or use a new casing.

</comment></comment></comment><comment><USER17> I'm wondering how it even got a 1. Any device that requires a Dremel tool to saw through it just to get at the insides should get a 0.</comment>


Ask HN: How do I get people to "fan" my facebook page? - <AUTHOR>

I suck at branding to normal consumers. I have no idea what to do to engage the consumers in a way that will fan my facebook page, or they will follow my product on twitter.<p>Are there any techniques to get this to happen? Most of the users just don't care enough about my product to go that extra step. Short of changing the entire product, what steps could I take to somehow gain fans? <comment><USER2> I'm just getting into Twitter for my business, and finding that as I give so I do receive. Depending on your vision will determine how scalable this model is - I'm shooting for 100 followers this week and 1000 by July 1st, and not all of this will be doable at that scale.

1) Sent the first few tweets that explained who I and the company are.

2)I followed x number of people who looked interesting and relevant to my business. Many of them followed back (very few auto-followed)

3) I installed TweetDeck to sit in the background when I'm online (and not in do not disturb mode) - there are often questions or observations from someone I follow that I can contribute to. I reply, and so far, most times I do they tweet a thank you, and I get 2-3 signups within 10 mins from their followers.

4) When I get a new follower, I have a quick look at who they follow or who follows them, for new leads to repeat Step 2.

5) Next step is to Direct message all new followers. In your case, that might be linking to your Facebook page?

A note on Facebook pages - it takes me four clicks _after_ I log in to access _my own_ fan page. The likelihood of me doing that for any other business? Nil.

</comment><comment><USER3> I have had success gaining fans for my Facebook page using Facebook ads. I targeted my ad to people who fit my niche and I gained fans fairly quickly. I also made sure to keep my fan page fairly active by posting there on a regular basis.

<comment><USER4> That's the route I'm currently taking.

I had been running Facebook ads linking directly to my "Farmville Timer" iPhone app on the app store. Then I realized I was getting no network affects from that. So I set up a fan page and I'm now running ads asking people to become fans. That way I'll also get noticed on people's walls and feeds.

<comment><USER5> Have you looked into running those ads actually in the game? I don't know how they manage or outsource those ads though.</comment></comment></comment>


Peanutty: solve puzzles, build puzzles, learn to code - <AUTHOR> http://peanutty.org/

<comment><USER2> If you're only going to support Chrome, you should at least show a screenshot or have browsable documentation or something on the site.</comment>


The Ultimate Cheat Sheet For Starting And Running A Business - <AUTHOR> http://jamesaltucher.quora.com/The-Ultimate-Cheat-Sheet-For-Starting-And-Running-A-Business

<comment><USER2> "99) I can change the world with my technology. No you can't.

99A) Corollary: Don't smoke crack."</comment>


Microsoft does right by freeing Outlook archives - <AUTHOR> http://news.cnet.com/8301-30685_3-20006128-264.html

<comment><USER2> Direct links: <http://pstviewtool.codeplex.com/> <http://pstsdk.codeplex.com/>

</comment><comment><USER3> The tools existed for at least 5 years, mostly through reverse engineering.

Apache incubates a few MS file format utilities, some of which are looking for maintainers/contributors:

<http://poi.apache.org/></comment>