Ask HN: Would you reach out to the competition? - <AUTHOR>

Pardon the deliberately vague post. This is about two teams with very complementary skills that are tackling the same problem and are at a very early stage. One team knows about the other and is considering whether and how to approach them for a possible team merge.
We are working on a product that takes a lot of passion to put to market because there isn't a successful precedent out there that it will work. It takes a lot of attempts at translating real world processes to the web but it will remove a tremendous amount of friction and add a ton of value if we get it right. Others have done tangential products and failed in the past, so no slam dunk by any means. I've recently discovered another team that is seemingly trying to solve the same problem. I think they are approaching things wrong from a strategy standpoint, but they may eventually learn better. Both of our teams are at a really early stage. Both teams have worked on the idea for more than a year and both of us are in Beta. They are in private, we less so. I think my team has a better brand, better traction, and a product-market fit somewhat established already because of that. The interesting part is that if combined, our teams have perfectly complementary skills and we are about to be living within an hour of each-other. The other team has also slowed down their promotions for some reason and is either redoing their product or giving up soon. So I started wondering: Should we combine efforts to solve this massive problem? Should I reach out to them? How would you do that? Would you even do it? It would be a very risky proposition and it would be a difficult conversation, because any information exchanged could be used against either of us. At the same time, I think if combined the joint team (of three founders) would be unstoppable. What would you do? How would you protect both teams?
P.S.(Please, don't seek out the other team.) <comment><USER2> Yes, do it. You're going to come across each other eventually. Why wait. Get out there and make the intro. You don't have to share your technology or strategy, just go and talk about your backgrounds, why you both entered the market, etc. etc.

Don't go in with the attitude that you should merge. You don't know that yet. All you know is that they are in the same market. You don't know if the two teams are a cultural fit, if they have strengths where you lack them, etc. etc.

</comment><comment><USER3> What do you have to potentially gain from it? More bodies, or minds, to " _solve this massive problem_ "? That you can't acquire otherwise?

Any effort along these lines, beside poaching individuals, is going to consume a _lot_ of energy; even if successful, the opportunity cost will be high and possibly fatal to your effort.

I'm also concerned by " _They are in private, we less so._ " In my personal experience, as well as general observation, that's ... very bad, and also says something about each company's corporate culture. So given that there's a noticeable difference, it adds a potential for (more) friction in trying to meld your companies together.

</comment><comment><USER4> I have but it has never lead to anything successful. Nothing harsh or abrasive has ever come up, it just ends up being a "Yeah!" reaction that fades with time to "Meh." or "That won't work" on their part.

</comment><comment><USER5> Without knowing anything else--fuck it, have them out for beers and see what happens?

What's the problem domain?

<comment><AUTHOR> A business with network effects if it works. The risks are: we borrow each other's strategies and go on a direct collision course, we merge and the teams don't mix, we merge and diverge in strategy later on... One of the teams has a single founder doing tech and hustling, so the two tech people may mix but the third person may feel threatened too. The upside - we are the best freaking team for this on the planet and we move twice as fast and everyone's financial risks are lowered by faster seed money and faster execution. (because nobody is making money yet)</comment></comment>


Dlint – Robust Static Analysis for Python - <AUTHOR> https://duo.com/blog/introducing-dlint-robust-static-analysis-for-python <comment><USER2> Hi HN, creator of Dlint here, happy to answer any questions you may have. I'd also appreciate any feedback or comments.

Here's a direct link to the repository: [https://github.com/duo- labs/dlint](https://github.com/duo-labs/dlint)</comment>


It started as a small idea. Now, it can change the world. - <AUTHOR> http://www.crowdreach.co

<comment><USER2> Put yourself in our shoes. You're trying to get us hyped up while giving us zero clues as to what it actually is. With the infinite amount of possibilities, I'm guessing people here would be more inclined to think "waste of time" than "cool mystery".

<comment><AUTHOR> Yes, I understand and you are probably right. In the next few days will get back with more information. Thanks.

</comment></comment><comment><AUTHOR> Can't give you more details at the moment but we're launching soon. I think you'll like it.

</comment><comment><USER3> You're gonna have to state at least what your thing is supposed to do...</comment>


Ask HN: What books will stay relevant for many years to come? - <AUTHOR> I just finished reading, The Design of Everyday Things by Don Norman and it is just amazing how the author has laid down principles of design that will stay relevant for many years even if the technology will change drastically.<p>What are books like this which will stay relevant for a long period of time? <comment><USER2> A quick heuristic is that older books that are still relevant today are more likely to remain relevant in the future. I don't know much about design books, but I would bet on Tufte books to remain relevant for a long time. Any really old book that is still in print would be a good candidate, and the older the more likely to stay relevant.

Other books that will be around for decades (or more) (to pick some non design things): The Bible, SICP, Feynman's Lectures, How to Win Friends and Influence People, Shakespeare.

<comment><USER3> Having done a paper on cyber war for school, I was surprised to find that the two books that were quoted most often by war theorists were Carl von Clausewitz's "Vom Kriege" and Sun-Tzu's "The Art of War" \- one is 200 years old, the other 2000...

</comment></comment><comment><USER4> If you are asking about the general books then the one which has been relevant from 5000 years and will always be relevant in future also is _Bhagwat Gita_

</comment><comment><USER5> Code complete and mythical man month stand up very well. As does K and R as a lesson in concise documentation even if it's a little outdated technically.

</comment><comment><USER6> Any book light on specifics (tactics) but heavy on theory (strategy) will age better because it will be less effected by changing circumstances.

</comment><comment><USER7> The Psychology of Computer Programming seems to be holing up well from its first publishing in 1971.

</comment><comment><USER8> Do you mean books in general or books on design and/or psychology, like Norman's?

</comment><comment><USER9> An algorithms book.

<comment><USER10> Its good to have an idea of algorihms, but in this day and age, only so you know the correct library to choose.</comment></comment>


6 monkeys given experimental vaccine did not catch COVID-19 after heavy exposure - open-source-ux https://www.businessinsider.com/monkeys-given-new-oxford-vaccine-coronavirus-free-strong-exposure-encouraging-2020-4 <comment><AUTHOR> the headline is somewhat clumsy: if they did not catch the virus, how can we know their immune systems fought it?</comment>


What if Lisp were invented by the Japanese? - <AUTHOR> http://lispnyc.org/blog/euske/what-if-lisp-was-invented-by-the-japanese <comment><USER2>
        (defn japanjure [& e]
          (reduce #(if (fn? %2)
                     (let [[l r & m]%]
                       (cons (%2 r l) m))
                     (cons %2 %))[]e))

        (japanjure
          4 5 +
          3 *
          print)

<comment><USER3> Someone explain?

<comment> T-R I'm not that familiar with lisp, but it looks like he wrote a macro that allows functions to be called in postfix

<comment><USER4> At the cost (among other things) of not being able to pass functions as arguments, though that could be worked around.

<comment><USER2> True. Japanjure needs a lot of work before it's enterprise ready.

</comment></comment></comment></comment></comment><comment> T-R Japanese is a head-final, strictly left branching language, as linguists might put it, which means it's structured like postfix.

This would actually let you read code strictly left-to-right (even though English speakers would be tempted to think of it as right-to-left) - when you read through functional programs, you end up reading a lot of the code right- to-left, due to function application, to see the order that code is actually executed. In postfix, the order objects/functions are written is the order they're executed.

Continuing along the lines of the post, a more Japanese programming language would also have named arguments (particles), and if it was object oriented, you wouldn't need to type 'this'/'self', since subject can be implied by context (well, it's really the direct object - the computer is the subject).

<comment><USER5> Interesting point with regards to functional programming, although it's worth pointing out that at least some functional languages have operators that allow you to do what you're describing. For instance, in F# instead of writing "f x" you can write "x |> f"

<comment><USER6> For functions of one argument that's easily enough defined in Haskell.

        x |> f = f x

<comment><USER5> I don't know Haskell very well, but I assume you're defining an |> function? If so that's pretty neat. Haskell's flexibility always impresses me. I think the F# version generally assumes one argument too, though I think you could use partial function application to work with multiple parameters.

<comment><USER6> Yes, that's right. Infix function names (anything made of symbols or delimited by backticks) are allowed on the LHS of a defining equation. An alternative syntax for this function would be this:

        (|>) f x = f x

The parentheses just serve to denote an infix operator being used in a prefix way.

A type signature makes this clearer:

        (|>) :: a -> (a -> b) -> b

As you can see, (|>) is a function which accepts an argument of type a, a function which takes an argument of type a and returns something of type b, and returns something of type b. In this way it's just a flipped version of the application operator ($), which has this type:

        ($) :: (a -> b) -> a -> b

</comment></comment></comment></comment></comment><comment><USER7> I think the brain is wired in such a way that it can handle different verb orders without reprogramming. Personally, the verb order in Japanese has never given me any trouble; combined with the way verb inflection works, I never have trouble picking out the verbs, even in the written language.

German, on the other hand, has this mechanism where verbs split and wind up with fragments stacked up the end of the sentence and that, combined with the need to master grammatical gender to answer questions like "who did what to whom?" causes me to have a much harder time parsing German, despite the use of the roman alphabet.

<comment><USER8> You can see remnants of separable verbs in English:

"I passed the man in the red hat by." pass-by

"I threw all of my old, useless papers out." throw-out

In the case of pass-by, we still have the verb bypass, but its meaning has drifted slightly from pass-by.

</comment></comment><comment><USER9> Also how it was done in the 50's by Americans. (Arthur Burks, Don Warren and Jesse Wright[1]).

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

<comment><USER10> That had more to do with limited computing power and putting things on a stack in the right order than it had to do with grammar.

</comment></comment><comment><USER11> Cute, but the prefix notation in LISP is not purely aesthetic; it is related to the fact that lists were stored in a first-rest (car-cdr) pair structure, and thus function calls (a list including the function itself and all its arguments) could be broken into the function and its list of arguments, using mechanisms already present.

I suppose you could then define car-cdr as a last-rest pair, but there are reasons aside from linguistic ones to want the first of a list to be the prominent one.

<comment><USER12> You could simply reverse the order of the arguments to cons.

<comment><USER11> It's more subtle than that, though. Every list has a beginning; not all lists have ends. If the 'car' semantics are "last item of the list" this is actually meaningfully different from "first item of the reversed list".

<comment><USER12> It's not meaningful at all. The list would just be constructed entirely from right to left. The "first" item in a pair would be on the right, and "car" would just mean "item on the right of a pair", or "first item in a list".

<comment><USER11> Are you also writing right-to-left, then? If _everything_ about the system is reflected (including having a reading order of right-to-left), then you're right, it's not meaningful. But it's also not what's proposed in the OP here. When the two-dimensional text on the screen is re-formed into a linear string, it is the right end of line N that is attached to the left end of line N+1, and so the right-hand arguments of functions are "after" the left-hand arguments.

</comment></comment></comment></comment></comment><comment><USER13> _It's fun to speculate the cultural influence on a programming language design._

There was a story Dijkstra told in his "Discipline of programming" - he gave his students a task where they had to process a set of items or something like that; and most did it in left-to-right order.

The only one to work right-to-left was Syrian or Egyptian - i.e. native Arabic speaker.

</comment><comment><USER14> There is a Forth-like programming language that can be programmed entirely in Japanese.

<http://www.scripts-lab.co.jp/mind/ver7/v7unix_download.html>

Example to add 4 and 5 (from <http://ja.wikipedia.org/wiki/Mind> ):

      4と 5を 加え 表示する。

<comment> T-R That is awesome.

Now I know what language to learn once I finish reading "Real World Haskell". I was gonna go for Factor or Forth, but this absolutely wins.

</comment></comment><comment><USER15> What would be interesting is if Lisp were invented by the Greeks. In Greek (I believe) there is no grammatical ordering. Each part of a sentence is declined according to what part of speech it is. So a noun is formed differently if it's an object or if it's a subject. Verbs are readily identifiable as well. So a sentence can be any of SVO SOV OSV OVS VSO VOS.

<comment><USER16> Latin has that structure.

Take a look at Lingua::Romana::Perligata, a Perl module that gives Perl a latin-style grammar: <http://search.cpan.org/perldoc?Lingua::Romana::Perligata>

Damian Conway, its author, wrote a paper about it as well: [http://www.csse.monash.edu.au/~damian/papers/HTML/Perligata....](http://www.csse.monash.edu.au/~damian/papers/HTML/Perligata.html)

<comment><USER17> Russian language also allows VSO, SOV, VOS, OVS, OSV - all of combinations is correct.

Although my 6-year son always prefers SVO. He has problems with with variants. He thinks they are "incorrect".

</comment></comment></comment><comment><USER18> You mean Urispu?

<comment><USER19> I have no idea what this comment means and it is already the highest Google hit, with all others not making any sense. Would you please care to elaborate?

<comment><USER18> It's the roman orthography of the closest sounds in Japanese to the word "Lisp."

</comment></comment></comment><comment><USER20> SUMMARY: Japanese may seem like double Dutch, but it's actually more like reverse Polish. ;)

</comment><comment><USER21> The Factor version of (((4 5 +) 3 _) print) would be

4 5 + 3 _* print

<http://factorcode.org/>

Also, Factor was influenced by LISP and Forth among other languages.

<comment><USER22> Factor really needs a book or large tutorial as it is one of the coolest languages out there but you still need to read a forth book or delve deep into the provided example problems to really get into it.

<comment><USER23> Start with "To Mock a Mockingbird." One way to think about languages like Factor and Joy is that they are direct representations of Combinatorial Logic, just as Lisp and it's descendants are representations of the Lambda Calculus:

[https://github.com/raganwald/homoiconic/blob/master/2008-11-...](https://github.com/raganwald/homoiconic/blob/master/2008-11-16/joy.md)

</comment></comment></comment><comment><USER24> It looks a lot like Forth (a RPN language). Many years ago I worked on a hardware project to build a Forth machine specifically for running ""reversed lisp"".

<comment><USER25> Many years ago I had the luck to work on a project that involved me writing a lot of code in both Lisp and PostScript (another RPN language, although not one commonly associated with manual code generation) - there is actually quite a lot that the two environments had in common - particularly the REPL and a relatively simple set of structural abstractions.

</comment></comment><comment><USER26> How do Japanese mathematicians denote function calls? I suspect that had more direct influence than English grammar.

</comment><comment><USER27> If lisp was invented by the Japanese, perhaps instead of:

      (((4 5 +) 3 *) print)
      ((((make-hash-table) table)) let ((table "one" gethash) 1 setf) table)

we'd have:

      (((4 5 +) 3 *) 打)
      ((((做井卓) 卓)) 让 ((卓 "一" 拿井)1 放f) 卓)

<comment><USER28> I don't think you'd see a Japanese caught dead using one of China's simplified characters like 让!

The character you picked for "hash" (井) was cute, but the actual word used in Japanese is "ハッシュ".

You're welcome.

<comment><USER27> I was just trying to make a point with the only N.E.Asian language I know anything about.

If the Japanese had used 讓 in a programming language, someone somewhere would have added 让 as an alias, which would have quickly spread. As for 井, it looks like # , which I call "hash"; again, it might have spread.

<comment><USER28> Tone of voice doesn't translate well into text---I wasn't picking on you. I was just being a nerd.

But just to be irritating, I don't think anyone would've added the alias, as inputting a kanji from an IME is as simple as choosing it from a list---and the one you want (regardless of complexity) is usually the first one on the list. It would make more sense if the language was handwritten. I heard somewhere that Donald Knuth writes his software by hand before inputting it, but I'm pretty sure he's an exception.

</comment></comment></comment></comment><comment><USER29> Isn't what the author describes almost exactly RPN (Reverse Polish Notation) aka postfix?

<comment><USER15> Yes. And as an avid HP-50g user, I wouldn't have much problem switching everything I do to postfix. After you get used to it, everything is a lot easier.

It is an interesting point the author makes concerning linguistic influence on using infix notation or prefix notation. Aside from grammar, there is really no reason to do things that way.

Consider the following sentences:

"Mix 2 eggs with 1 cup flour" (prefix)

"We ate dinner" (infix)

In both cases, the first step is to fetch the operands, being 2 eggs and 1 cup flour and "we" and dinner. Only after we fetch them can we apply the operator, to mix and to eat. Both of these sentences are carried out in postfix.

That's the way cpu instructions are executed. The read stage comes before the execute stage.

<comment><USER29> HP 42s user here. A few years ago I went to buy a second one, so went to EBay... they were going for a few hundred dollars. I bought mine for about $90 new. One of the few pieces of electronics that seems to have gone up in price.

<comment><USER30> Another HP50g user here. My friends disliked the RPN mode for the first few weeks (they couldn't borrow my calculator), but even they got used to it within 10 minutes of button mashing and errors.

Has anyone actually been able to use all of its built-in functions though?

</comment></comment></comment></comment><comment><USER31> Then it might look a bit like ruby, designed by this Japanese fella: <http://en.wikipedia.org/wiki/Yukihiro_Matsumoto>

</comment><comment><USER20> Similar: [http://metamerist.blogspot.com/2007/02/alan-kay- oopsla-1997....](http://metamerist.blogspot.com/2007/02/alan-kay- oopsla-1997.html)

</comment><comment><USER32> Do we discuss about order? For me it is same if you prefer Method(self param) or X.method(param)...

</comment><comment><USER33> It's worth pointing out that the default word order of English is SVO, and not VOS/VSO like the "word" order of LISP. Perhaps, John McCarthy is a native speaker of Malagasy?

<comment><USER34> Given that imperative sentences in English map onto function calls rather well, and also have an understood subject, I think Malagasy is an unnecessary assumption.</comment></comment>


Show HN: Shots - Screenshot manager for macOS - <AUTHOR> https://www.producthunt.com/posts/shots-3 <comment><USER2> Based on the screenshot, it looks like the user's account photo is shown in the sidebar, constantly. Why?

Also, the company info in the bottom 1/3 of the sidebar is pretty cheesy. Maybe that's acceptable in Windows apps, but it stands out like a sore thumb amongst Mac Apps.</comment>


64-bit unix timestamp is not supported in MySQL functions (2005) - <AUTHOR> https://bugs.mysql.com/bug.php?id=12654 <comment><USER7> Note - MySQL Have 2 data types. One is TIMESTAMP which is signed 32bit timestamp which is very useful for times around now. There is also DATETIME type which has broad range and this is what you should use in general

<comment><USER8> MySQL has more unfortunately-named time-related types than Python, which IMO is quite the achievement:

       - <USER2>
       - <USER3>
       - <USER4>
       - <USER5>
       - <USER6>

<comment><USER9> Whoever set up the database for my current work project apparently thought that wasn't enough, because it's got a whole lot of columns called "dateTimeStamp" which--on inspection--turn out to be VARCHARs containing a string representation of a timestamp. In ISO 8601 format. The one that looks like "2019-12-11T00:04:37.754329Z".

Yes, they actually have six decimal digits of precision. For tracking boxes on a warehouse conveyor belt.

<comment><USER10> First time I've seen someone complain about finding standard ISO 8601 in a database.

<comment><USER9> This particular database is mainly used to display results to humans, and whoever wrote the original code didn't bother to convert it from 8601 to human-readable (one of the things I'm fixing), so it stands out.

</comment></comment></comment></comment></comment><comment><USER11> Is this the only part of MySQL/MariaDB that is known to have a Year-2038 issue?

<comment><USER12> Yes. UNIX_TIMESTAMP(), FROM_UNIXTIME(), and the TIMESTAMP datatype. Everything else time related appears to be fine.

</comment></comment><comment><USER13> Going to be an interesting birthday for me that year. Still surprised that this hasn't been fixed yet, we've known about it for a while.

</comment><comment><USER14> Apparently, it's also an issue with MariaDB.

<comment><USER15> I don't know, but I also don't know why anyone didnt make the switch to MariaDB yet...

<comment><USER7> Ignorance is bliss ?

Non of the top Internet dogs - Facebook, Twitter, Uber run MariaDB

<comment><USER12> There's at least one that does.

[https://www.theregister.co.uk/2013/09/12/google_mariadb_mysq...](https://www.theregister.co.uk/2013/09/12/google_mariadb_mysql_migration/)

And Wikipedia: [https://blog.wikimedia.org/2013/04/22/wikipedia-adopts- maria...](https://blog.wikimedia.org/2013/04/22/wikipedia-adopts-mariadb/)

<comment><USER7> Some do. But MySQL is far much more popular on large scale environments.

In Google BTW I'm not sure how much MySQL/MariaDB is left at all. They have been moving most of the stuff to Spanner.

</comment></comment></comment></comment></comment><comment><USER16> Ran into this issue on a project I work on :P

</comment><comment><USER17> This is going to be great for programmer job security in 2036/2037 if we just keep it hush hush for awhile longer.

<comment><USER18> 2038consulting.com is my long-con / retirement plan, but I'd be happy to have this as a solved problem in the next decade instead.

</comment></comment><comment><USER19> Reason 34,583,498 to use Postgres instead of MySQL.

<comment><USER8> Also to not use the TIMESTMAP type in general, which is full of similar by- default footguns (off the top of my head: default 1-second precision, connection-local timezone autoconversion). At least for non-historic events.

Use uint64 as nanoseconds from epoch. Explicitly convert to/from UTC in your application code. Smear your leap seconds. This will last you until 2554, by which time I hope computers as we know are dead. Bonus: these make for decent strong-read-ordered internal UUIDs, given good retry logic.

<comment><USER20> I am looking at just this design pattern now (pseudo uuid) can you elaborate on "given good retry logic"?

<comment><USER21> I assume that on conflict just retry again, the timestamp will be different.</comment></comment></comment></comment>


Twitter Wants to Stop You from Using Twitter Apps Not Made By Twitter - <AUTHOR> http://gizmodo.com/5935517/twitter-wants-to-stop-people-from-using-apps-not-made-by-twitter?utm_campaign=socialflow_gizmodo_facebook&utm_source=gizmodo_facebook&utm_medium=socialflow <comment><USER2> Then maybe they should, I don't know, update their apps?

</comment><comment><USER3> I'm just going to stop using Twitter instead.</comment>


Makefiles – Best Practices - <AUTHOR> https://danyspin97.org/blog/makefiles-best-practices/ <comment><USER2> I recently decided it was time to get a better understanding of how makefiles work, and after reading a few tutorials, ended up just reading the manual. It's long, but it's very, very well written (a good example of one of the Gnu projects biggest strengths), to the point where just starting at the top and reading gives an almost tutorial-like effect. Just read the manual!

<comment><USER3> FWIW I also read the GNU Make manual, and based some code for automatic deps off a profoundly ugly example it had. Then later people on HN showed me a better/simpler way to do it.

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

[https://www.gnu.org/software/make/manual/html_node/Automatic...](https://www.gnu.org/software/make/manual/html_node/Automatic- Prerequisites.html)

After reading the manual and writing 3 substantial Makefiles from scratch, I still think Make is ugly and, by modern standards, not very useful.

In my mind, the biggest problem is that it offers you virtually no help in writing correct parallel and incremental builds. I care about build speed because I want my collaborators to be productive, and those two properties are how you get fast builds. GNU Make makes it easy to write a makefile that works well for a clean serial build, but has bugs once you add -j or when your repository is in some intermediate state.

<comment><USER4> > In my mind, the biggest problem is that it offers you virtually no help in > writing correct parallel and incremental builds.

That's interesting, because in my mind, parallel and incremental builds are the main features of Make, the features that it is best at, and all other features are secondary.

It sounds like your problem is with the correctness part. Make gives you no tools to enforce that your build rules are actually correct. Very few build systems provide any help here. What you are looking for is hermeticity. Bazel does this by sandboxing execution of all the build rules, and only the specified rule inputs are included in the sandbox. I recommend Bazel.

Otherwise, it is up to you to get your build rules correct, and switching build systems won't help in general (although they may help in specific cases).

I find it surprising that you talk about using Make for a clean serial build, because if you want a clean serial build, you might as well use a shell script. Make's only real purposes are to give you tools for incremental and parallel builds. Nearly any other tool you replace Make with will either have you sacrifice incremental/parallel builds or will give you the same hermeticity problems you would encounter with Make. Replacing Make, the main paths I see are towards improved versions of the same thing (e.g. Ninja, tup), completely redesigned versions of the same thing (Ant, SCons), systems and languages which generate makefiles (e.g. autotools, CMake), and the new wave of build systems which provide hermeticity (Bazel, Buck, Pants, Please). This last group is a very recent addition.

Mind you, Make is old and not especially well-designed, and it has plenty of limitations, but it's good enough at incremental/parallel builds that it has stuck around for so many decades. Make is good enough at what it provides that replacements like Ant, SCons, Tup, Ninja, etc. don't seem like much of an improvement.

<comment><USER5> As I recall, the guy who developed Make wrote it in a weekend.

<comment><USER4> And never expected it to be so successful, and realized that he couldn't fix some of its problems because people were already relying on it.

</comment></comment></comment></comment></comment><comment><USER6> GNU Make is an awesome task-runner. I use it all the time, for all sorts of things. It's my shell-script replacement, and I write one-off Makefiles frequently. It's got a nice macro-processor, some helpful string manipulation tools, and expresses task dependencies perfectly. The manual is also very well written.

But if you're writing a software package, consider using CMake, Meson, Autotools, or something similar. Unless you're a superhuman, any of them will handle the corner cases better than you can. Especially the cross-compilation corner-cases. It's extra work, but the people who need to build and package your software down the road will thank you. Your artisan Makefile might be an elegant work of art, but what does it do when somebody wants to build from a different sysroot? Does it handle DESTDIR correctly?

<comment><USER7> I haven't found a reason to not just use Make yet when starting from green fields, including some very big projects. In fact, I have often been annoyed at some projects picking something like CMake for no reason beyond it's "more advanced," but which ends up just being an extra dependency I have to fetch and install.

If I were to pick one of the above for building large projects on linux variants, which one would you pick?

<comment><USER6> For me, I mostly work in embedded Linux - that's Linux for routers, custom hardware, sometimes a Docker image, etc. That means lots of packaging work. Sometimes it means build machines that can't even run the compiled binary. I compile libraries for platforms that the original author would never have imagined.

In that space, there are lots and lots of details that need to be "just so". Lots of specifics about the cflags and linker flags. Requirements on where 'make install' puts files. Sometimes restrictions where an output binary wants to search for config files (spoiler: use sysconfdir).

Out of all the libraries/programs that I've had to package, autotoolized projects are the easiest to handle by far, followed by CMake projects.

Hand-written Makefiles are usually painful to a packager in one way or another. The most common ones being hard-coded CC/CXX/CFLAGS/CXXFLAGS, non- standard target names, and non-standard/incomplete usage of directory variables.

I know that Autotools is crusty in a lot of ways, and that the learning curve is steep. It's a nasty mix of Perl and m4, and runs lots of checks that don't matter at all. It's also what I use for all of my own libraries and programs, because the result is worth the pain (for me).

So for any program that I expect more than two humans to ever compile, I'd recommend Autotools if you're a perfectionist and CMake if you're not. Within Autotools, I'd recommend Automake and Autoconf if the language is C/C++, and just Autoconf/Make otherwise. (But be sure to follow the Makefile conventions: [https://www.gnu.org/software/make/manual/html_node/Makefile-...](https://www.gnu.org/software/make/manual/html_node/Makefile- Conventions.html)).

I wouldn't recommend a hand-rolled Makefile unless you're the only one using it, the build is really weird for some reason, or unless it's a wrapper around some other build tool.

<comment><USER7> Thank you for the detailed response!

</comment></comment></comment></comment><comment><USER8> I really wish blog posts like this would at least mention that they are going to use GNUMake extensions. There's some good stuff in here, but just calling it "make" and leaving it at that is misleading. It's not going to work on my minimal (non-GNU) Linux boxes that mostly run NetBSD make (bmake in many distros) or busybox style tools. I know a very small minority of people do something like that (or maybe not, what does Alpine run in containers?), but it seems worth at least a quick footnote to say that most things in here won't be portable.

<comment><USER9> I doubt most people even know that there are different versions. (I didn't!)

<comment><USER10> It's pretty common knowledge that there are differences from the GNU package set and linux package sets.

I've been exposed to this multiple times: from downloading GNU packages using Homebrew on OSX, downloading different packages on Android, the variety of options available to ArchLinux users, etc.

Anyone with basic Linux knowledge should be well aware of this. From a minimum of following tutorials and having the basic command flags not work on common terminal programs.

<comment><USER9> I don't agree that "basic Linux knowledge" requires knowing which commands have different versions. You can be intimately familiar with the Linux kernel and never step outside of the GNU environment.

I've never used OSX, and have no desire to compile things on my phone.

And I know that there are non-GNU versions of some tools, like grep, but whenever I've attempted to use them, I find them lacking some key feature that I always use. I can't be bothered to learn the entire set of GNU-improved tools, since I'm always just going to be using the GNU version anyway.

</comment></comment></comment></comment><comment><USER11> For those interested, there's also this writeup of making portable makefiles on nullprogram[1]

[1]: [https://nullprogram.com/blog/2017/08/20/](https://nullprogram.com/blog/2017/08/20/)

</comment><comment><USER12> Please add to this list "If you use GNU Make specific syntax, use the name GNUmakefile".

[https://www.gnu.org/software/make/manual/html_node/Makefile-...](https://www.gnu.org/software/make/manual/html_node/Makefile- Names.html)

</comment><comment><USER13> > Using the assignment operator = will instead override CC and LDD values from > the environment; it means that we choose the default compiler and it cannot > be changed without editing the Makefile.

People can use `make CC=clang` to override assignments. That's a pretty common use.

<comment><USER14> Came here to say this. The "strength" of user specified variables depends on where they come from: the environment is weaker than those specified as command line arguments - which can lead to confusion.

</comment></comment><comment><USER15> There are so many gotcha with makefiles yet we still use them regularly. I'm considering moving on to something like Taskfile [1], though I haven't tried it yet.

[1]: [https://taskfile.org/](https://taskfile.org/)

<comment><USER16> I've been using invoke [1] which has allowed me to give my projects nice UIs while remaining in the primary language. If I were working on Ruby I would stick with Rake, even though I think invoke is better.

[1] [http://www.pyinvoke.org/](http://www.pyinvoke.org/)

<comment><USER15> I really like Invoke / Fabric for Python projects, though it feels weird to use in non-Python projects when it comes to dependencies. [Now I have to explain to non-Python people things like virtual envs, pipenv vs pip vs pipsi, pyenv, etc.]

Just curious if you install Invoke individually for each project or keep one global install?

I suppose I could always git exclude the tasks.py Invoke files.

<comment><USER17> I usually keep Invoke globally installed that way I can use it for setting up and interacting with pipenvs externally. Most of my calls beside the initial setup make use of 'pipenv run <command>' that way I never actually have to navigate inside of the virtualenv for most cases.

</comment></comment></comment></comment><comment><USER18> A particularly tricky task with GNU make is automatically adding target dependencies on header files and handling updates to them (gcc's -M and -MMD switches). It would be great if the article explained those best practices, too.

<comment><USER19> [https://www.cmcrossroads.com/article/tips-and-tricks- automat...](https://www.cmcrossroads.com/article/tips-and-tricks-automatic- dependency-generation-masters)

<comment><USER20> Thanks John, your book is the most-referred to on my office shelf ;)

Edit: [https://nostarch.com/gnumake](https://nostarch.com/gnumake) (via [https://blog.jgc.org/2015/04/the-gnu-make-book-probably- more...](https://blog.jgc.org/2015/04/the-gnu-make-book-probably-more- than.html))

<comment><USER21> I also recommend this book. The series on "meta programming make" is also quite good: [http://make.mad- scientist.net/category/metaprogramming/](http://make.mad- scientist.net/category/metaprogramming/)

<comment><USER19> Ooh. That's great. I had not seen that!

</comment></comment></comment></comment></comment><comment><USER22> I've been using makefiles for decades, and finally decided to try something more modern.

It turns out that CMake has come a LOOOONG way, and is almost nice to use, aside from the fact that it's horribly complicated. But with some basic templates to work from, it's actually pretty easy to get a project started.

[https://github.com/kstenerud/modern-cmake- templates](https://github.com/kstenerud/modern-cmake-templates)

<comment><USER23> Or just use Rust. :3

Cargo handles makes with very simple TOML scripts, and it's the more modern language, to boot.

<comment><USER22> I've been planning to, but unfortunately it still lacks 128 bit float and decimal types, which I need.

<comment><USER24> You may be interested in this crate which adds decimal types [https://crates.io/crates/rust_decimal](https://crates.io/crates/rust_decimal). Here is another that I have not used but appears to add a f128 type [https://crates.io/crates/f128](https://crates.io/crates/f128).

</comment></comment></comment></comment><comment><USER25> Make is a very underappreciated tool outside C/C++ circles.

I'm currently using it in an environment which uses Concourse as the CI tooling - Concourse takes care of version and dependency management at its level, and Make fills in the gaps for fetching the latest versions for local development environments. Because Make won't re-download files for already- made targets, local build cycles are fast after initial setup. Concourse can then re-use these Makefiles by symlinking the resources it manages before calling make, and Make won't try to re-download the resources. If you're not concerned with portability, you can even use make to fetch (and clean) Docker images since they live in predictable directories on Linux (but not OS X).

More people ought to approach the tool with an open mind.

</comment><comment><USER26>
        CFLAGS := ${CFLAGS}
        CFLAGS += -ansi -std=99

What's the point of the first line? Why not just:

        CFLAGS += -ansi -std=99

<comment><USER27> Because CFLAGS may not be set in the environment, resulting in concatenation to an undefined variable error.

<comment><USER19> No such error occurs.

        $ cat Makefile
        FOO += foo

        all: ; @echo $(FOO)
        $ make
        foo

<comment><USER27> My bad, I felt like I've seen that error pop up before in my Makefiles, but I should have double-checked before commenting.

</comment></comment></comment></comment><comment><USER28> I have never worked much with compiled languages but I recently started creating gnu makefiles in all my projects. I read someone's article, maybe from here, that gave me the idea.

I have been putting everything in it. From the terminal commands needed to spin up the cloud infrastructure to all the docker build commands and of course all the build tasks like gulp and composer.

Even my docker compose commands have been replaced with "make up" and "make down". It is really handy and has really streamlined a lot of processes when it comes to local dev environment issues with different developers.

I basically just use it as an easy way to organize shell scripts.

The next step is to convert my ci/cd pipeline to just use specific makefile commands from the same makefile so that everything is more portable and I can easily execute the exact same process locally when desired.

</comment><comment><USER29> Next up: Automake, best practices

Publication date 2025

5000 pages

<comment><USER30> Or a single page with a single word:

No

</comment></comment><comment><USER31> Best practice is to keep it simple. For example, if the Makefile is written in such a way that lazy set or immediate set doesn't matter, then it is not complex at all. But these facilities are there for achieve logic. Complex logics are complex, especially when they are entangled. For example, we often use build tools to generate Makefile. Some of the logic is implemented in the build tool; some of the logic is implemented using Makefile -- of course the result is complex. There is no rule of thumb on how to organize complex logic, that is what programmers are paid (so much) to do. Respect your job and treat complex logic carefully, then you won't make too much a mess -- at least do not complain about it after making one.

</comment><comment><USER32> If you're using GNU make, as the author appears to be doing, makefiles should be named _GNUmakefile_ instead of _Makefile_ so as to not confuse the user or the tools by conflating GNU make with BSD make or other make dialects.

</comment><comment><USER33> Does the "?=" operator behave like ":=" or like "=" ?

<comment><USER19> Both

        $ cat Makefile
        $(info FOO $(flavor FOO))
        FOO ?= foo
        $(info FOO $(flavor FOO))

        BAR :=
        $(info BAR $(flavor BAR))
        BAR ?= bar
        $(info BAR $(flavor BAR))

        BAZ =
        $(info BAZ $(flavor BAZ))
        BAZ ?= baz
        $(info BAZ $(flavor BAZ))

        $ make
        FOO undefined
        FOO recursive
        BAR simple
        BAR simple
        BAZ recursive
        BAZ recursive

If undefined then becomes recursive, otherwise the flavour is preserved.

<comment><USER34> Make variable expansions are always recursive.

For what you're describing I think the proper term as used by the GNU Manual is deferred. In other languages the phrase lazy evaluation is common.

The one thing I've always had trouble remembering with GNU Make is precedence. Variables defined as command-line arguments (make FOO=bar) override assignments, but environment variables (FOO=bar make) only override ?= assignments. != is both immediate (the shell expansion) and deferred (the result of the shell expansion).

I _feel_ like there's some inconsistency when variables are inherited across recursive invocations, but in a simple test with make 3.81 (macOS) I couldn't find any. Maybe my suspicion is just a byproduct of my weird inability to remember the precedence rules.

I normally try to stick to portable make these days, anyhow. Between the ancient version of GNU Make on macOS, OpenBSD Make, and NetBSD Make, you're mostly stuck with POSIX syntax. If you add Solaris' default make, and _especially_ if you add AIX' make, you can't rely on any extensions at all.

For me sticking with portable make is easier than installing and maintaining GNU Make on every flavor of operating system I test on, and definitely easier than installing autotools or installing and maintaining the most recent version of CMake.

<comment><USER19> The GNU Make manual defines two variable types: recursively expanded and simple (see: [https://www.gnu.org/software/make/manual/html_node/Flavors.h...](https://www.gnu.org/software/make/manual/html_node/Flavors.html)).

</comment></comment></comment></comment><comment><USER35> This is pretty cool summary. Thanks.

</comment><comment><USER36> What about using Python (with system calls) to build the project? Much more understandable than Makefiles.

<comment><USER37> OK, so I am as much of a hard core Pythonista as you will find. But I don't think it makes any sense to build C projects (or many other languages) with Python instead of makefiles. C programmers know make, the makefile idiom has been evolving for 40+ years. A seasoned C programmer is going to look at an idiomatic makefile and find it much more readable than some rando doing some one-off Python script to control a build. And getting build dependencies resolved correctly so that you can only build what is need is not trivial.

What I truly hate is all the IDE's that think they can do a better job than make. This is the curse of the embedded world. Building an embedded project requires calling particular tools, with peculiar flags, and I hate with a passion IDE's that obscure all of that in some crappy XML file that is git- unfriendly. A well-structured makefile is your friend in many ways.

make is a powertool. Learn it and your life will be better.

<comment><USER38> As a C developer I have to say there exists no idiomatic makefile - configuring header file dependencies with -MMD/auto rebuild targets affected by FLAGS change already makes your Makefile look like magic. As the project grows, eventually you will need some kind of flexibility that makefile cannot do well. In this case, explicit Python scripts become more useful that a bunch of possibly implicit makefile rules.

<comment><USER39> Perhaps we need some kind of make8 tool to check for best practices and prevent us writing these magic make files.

</comment></comment></comment></comment><comment><USER40> Makefiles, Best Practices: Don't write Makefiles, use a higher level language to describe your goal and some tool to execute it (either directly or through generating a Ninja file).

The Make language is the assembly language of build systems. Do you really enjoy writing assembly all the time?

<comment><USER41> I have yet to find a build system I prefer over Make. I use Maven at work and use a Makefile to run mvn. It lets me easily run a wide variety of commands locally as part of my build.

<comment><USER40> Sure, if you're running commands, but you're not building Java directly with it. That seems reasonable.

</comment></comment></comment><comment><USER42> "Makefile, Best Practices: Use CMake to generate them for you"

<comment><USER43> You joke, but I've personally never seen a hand made make build systems, in any company I've worked at, that could handle "fuzzing" by deleting or modifying random files in the build system and having the expected output.

They all required a "clean" to get back in order.

For those that maintain handmade make based build system of reasonable complexity, I challenge you to "fuzz" it before each build. It will not be a comfortable experience.

On the other hand, I've seen many generated makefiles that behaved correctly that are totally unreadable.</comment></comment>


Reflecty – a mirror as heart of your smart home - <AUTHOR> https://reflecty.co/ <comment><AUTHOR> A friend of mine and recently created reflecty, a intuitive gesture controlled smart mirror. During the last one month and a bit we both worked day and night, to make out of the idea something real. With reflecty you can check the news, find out about the weather or get informed, when the next bus or tram arrives.

Although we only finished the first prototype some days ago, we are already planning a follow up with many improvements and lots of new features.

You can find out more about reflecty on its project website: [https://reflecty.co/](https://reflecty.co/)

</comment><comment><USER2> Wow, this seems to be an awesome product! Well done guys.

</comment><comment><USER3> I wish I could buy one immediately! SO awesome!

</comment><comment><USER4> I WANT THIS! NOW!</comment>


Smallest x86 ELF Hello World - <AUTHOR> http://timelessname.com/elfbin/ <comment><USER2> The classic resource for this (does the same sort of tricks, taken to an extreme: code overlaid with tables, tables overlaid with other tables, etc.):

<http://www.muppetlabs.com/~breadbox/software/tiny/>

(62-byte hello world among other things)

<comment><USER3> how about 45 bytes...

[http://www.muppetlabs.com/~breadbox/software/tiny/teensy.htm...](http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html)

<comment><USER4> How about 31 bytes?

<http://www.returninfinity.com/baremetal-helloworld.html>

Why use ELF or Linux? Flat binaries (and a custom OS) to the rescue! :)

<comment><USER5> Why limit yourself to an OS? Design your own instruction set, with a single- bit 'hw' instruction!

As with all games (even Nomic) a game is only a game if there are rules that limit what one can do.

<comment><USER6> The esoteric language HQ9+ does this.

</comment></comment></comment></comment></comment><comment><USER7> Other than as an interesting intellectual exercise is there any reason to do this on a modern computer with Virtual memory?

Surely, once you get below page-size (e.g. 4K) you are just wasting memory that will get loaded anyway?

<comment><USER8> Well, on one of the Dart threads, bashing its hello world size, this[1] came up:

 _Compile "Hello world" into an executable, and see how many kilobytes it takes on most architectures, despite the object file being a few bytes._

This thread pretty much responds to that. It is no 17000 lines, nor 17000K, it is just 142 bytes (other comments suggest it is 62).

[1] <http://news.ycombinator.com/item?id=3098660>

<comment><USER7> It makes more sense for VM byte-code as the bytes not only have to be loaded (probably by the page, again) but the bytes have to be run and possibly jitted, too.

</comment></comment></comment><comment><USER9> Doing it in C with mixed assembly

      [surki@linux-vrse tt]$ cat | gcc -nostdlib -x c - -o helloworld
      #define SYS_exit  1
      #define SYS_write 4
      #define stdout    1

      int strlen(const char *str)
      {
        long len = 0;
        while (str && *str++)
        {
            len++;
        }

        return len;
      }

      void print(const char *str)
      {
          int len = strlen(str);

          long ret;

          /* Can't touch ebx directly, PIC uses it */
          __asm__ __volatile__ ("pushl %%ebx\n"
                                "movl  %%esi, %%ebx\n"
                                "int   $0x80\n;"
                                "popl  %%ebx"

                                "a" (SYS_write),
                                  "S" ((long) stdout),
                                  "c" ((long) str),
                                  "d" ((long) len));
          return;
      }

      void _start()
      {
        main();

        __asm__ __volatile__ (
             "xorl %%ebx, %%ebx\n"
             "int $0x80\n"

             "a" (SYS_exit));
      }

      int main()
      {
        print("Hello World\n");
        return 0;
      }

      [surki@linux-vrse tt]$ strip -R .comment -R .comment.SUSE.OPTs -R .note.gnu.build-id helloworld
      [surki@linux-vrse tt]$ ll helloworld
      -rwxr-xr-x 1 suresh users 540 2010-07-21 13:19 helloworld

      [surki@linux-vrse tt]$ ./helloworld
      Hello World

</comment><comment><USER10> can get a few bits off by using some well known shellcode techniques. I think xor ebx,ebx is smaller than mov ebx,0, for instance.

<comment><USER11> You are right in that

        31 c0             xor %eax, %eax

is shorter than

        b8 00 00 00 00    mov $0, %eax

but that's not the main reason it's often used in shellcode. The xor reg, reg is preferred because it means the resulting shellcode will not contain a null byte. This is desirable since the null-byte is often used as a string terminator, in environment variables for example.

<comment><USER12> Another reason to use xor: in the old days, ALU reg-reg commands were generally faster than reg-mem moves.

The 8086 assembly tutorial book I used then recommended to use "sub ax, ax" instead because it was less surprising.

</comment></comment></comment><comment><USER13> same for win32 PEs: <http://www.phreedom.org/solar/code/tinype/>

</comment><comment><USER14> I wonder if this could be improved with genetic algorithms or similar. The code is pretty small, but the seach space is still pretty huge.

<comment><USER15> Did you post in the wrong thread?

<comment><USER14> Nope. Why couldn't you use a generic optimizer to optimize a piece of code?

<comment><USER15> Because it doesn't make any sense? What, are you planning just randomly try every permutation of 142 bytes?

You can't have a genetic algorithm run on something where almost every attempt will simply produce invalid code. Genetic algorithms work when you can try various strategies to maximize a fitness function. But here the fitness is yes or no, does it work or not. There is nothing to maximize - and you can't try to maximize the "size fitness" because pretty much all the attempts will produce invalid code, so there is nothing to mix together for various generations.

<comment><USER14> I disagree completely. The fitness function is clear, and that fact that many children will produce invalid code is not that much of a problem, really. You just eliminate them.

Google "automatic programming" if you think it's never been done, your mind is about to be expanded.

You should really learn to think for a while before you dismiss ideas as "nonsensical".

</comment></comment></comment></comment></comment><comment><USER16> a cool project would be to make a webapp that implements the following contest: create an ELF binary to do X with the smallest number of bytes.

<comment><USER17> ...why not just use the Stack Exchange "Code Golf" website?

(<http://codegolf.stackexchange.com/>)

</comment></comment><comment><USER18> Is this the next "how fast is Fibonacci" fiasco?

</comment><comment><USER19> Very impressive.

</comment><comment><USER20> $ echo "Hello World" > hw.php && php hw.php Hello World $ ls -l hw.php -rw-r-- r-- 1 gareth staff 12 Oct 11 11:23 hw.php

By this stupid metric, PHP is the greatest programming language ever made.

12 byte Hello World _must_ mean that it's also the ideal solution for every other programming problem, right?

<comment><USER21> I believe you _entirely_ missed the point. This was more of an "Look at how you can abuse the loader and play with ELF headers" and in general show an interesting 'hacky' article, not "this is smaller, thus more efficient" argument.

<comment><USER20> I figured this was posted as a related article to the Dash "Hello World" issue where people are pointing at 17,000 lines of Hello World code, because it includes the runtime when compiled to Javascript.

There was another comment about how this will be the next "Fibonacci debacle", related to how Ted Dzubia trolled the node.js crowd by pointing out it's weakness for CPU-intensive tasks, then had a ton of people wasting time on writing faster Fibonacci algorithms in node just to prove him wrong.

My point was that comparing languages by the size of their Hello World programs is a useless exercise.</comment></comment></comment>


Stop blaming PowerPoint. Learn how to kick some arse with it - <AUTHOR> http://www.technotheory.com/2008/06/stop-blaming-powerpoint-learn-how-to-kick-some-arse-with-it/ <comment><USER2> Summary: incompetent presenters use powerpoint badly. the incompetent event planners who hire them decided to blame powerpoint and make rules restricting its use. this is stupid and does not in fact solve the problem of having hired incompetent presenters.</comment>


Help us find the coolest educational apps - <AUTHOR> http://blog.zzish.com/post/134729113789/help-us-find-the-coolest-educational-apps <comment><AUTHOR> When schools were recently asked in a survey what areas would they increase their ICT investment, they said, 'assessment'. We listened to those teachers and worked with schools to create this amazing assessment platform to track their students progress. We are currently in the process of finding the coolest educational apps for our community of 10,000 teachers.</comment>


Thunderbird 3.3 is Approaching - <AUTHOR> http://www.linux.com/learn/tutorials/421515-message-to-the-universe-thunderbird-33-is-approaching <comment><USER2> I like thunderbird. It's probably my second favourite email client after Mutt.

I switched from Firefox to Chrome as I found Firefox too slow and bloated. I hope that in the process of integrating Firefox technology, thunderbird doesn't suffer the same fate.</comment>


A 55yr Old Developer Tells Us What It's Like In A Youth-Obsessed Silicon Valley - <AUTHOR> http://www.businessinsider.com/what-happens-to-older-developers-2014-3

<comment><USER2> He may be in the 'youth-obsessed Silicon Valley', but aren't non-startups less youth-obsessed, and youth likely don't want to get involved in old-staid big business.

I say this because here in Sydney, Australia, I'm amazed at how many positions there are in finance for a Java developer, or C developers at places like Dolby Labs, or .net developers all over the place. I'd suspect a 55 year old generalist to have the abilities to get into one of these more stable jobs. Do they really not exist in San Francisco? What about in other states?

I'd think most start-ups are using more modern languages/frameworks (Rails or Node.js specifically), so that may not be appealing to an older developer either.

I say this as somebody who is approaching older developer age. I've just turned 40, and though I have kept up to date with the latest languages and frameworks, I suspect that if I continue to develop for another 20 years, I may not always be up on the newest thing, which is why I'm trying to focus not on what's hot today, but what I think will be a solid background in 5 years. If I get that right, then hopefully in 15 years, people will still be using those systems or looking to migrate to something newer, and hopefully there is an opportunity for me there.

<comment><USER3> "I'm trying to focus not on what's hot today, but what I think will be a solid background in 5 years." \- any tips?

<comment><USER2> The way I look at it is to not jump on every new thing that comes along, but try to keep on eye on what's growing and what people are excited about.

For me, at the moment, that means Angular and Node. Four years ago it was Rails and Backbone. I'm keeping an eye on React, but am not ready to jump on that bandwagon yet.

Lots of people may suggest Haskell, Scala, Go, Ember, React, etc. etc. and I may add one or two of those in the future, but at this point, I don't see enough broad interest in those languages to make it on my list yet. Keep an eye on job postings and you'll see trends in languages and frameworks growing.

<comment><USER3> Angular and Node are exactly fresh new things. I would say it is better to learn MVVM/MVC and Reactor patterns those respective frameworks are based on.</comment></comment></comment></comment>


Does a Cop Have a Right to Your Smartphone? - <AUTHOR> http://techcrunch.com/2011/07/26/does-a-cop-have-a-right-to-your-smartphone/

<comment><USER2> Anyone have a link to the video they were referring to in the clip?</comment>


Yahoo makes it difficult to leave its service by disabling email forwarding - <AUTHOR> https://techcrunch.com/2016/10/10/yahoo-makes-it-difficult-to-leave-its-service-by-disabling-email-forwarding/ <comment><USER3> Just be careful about "deleting" your Yahoo account.

> Register a previously used ID

> A deleted Yahoo account ID may become available for future use, and you're > welcome to try to register it. However, Yahoo can't specify how long until a > deleted ID may become available, and we can't guarantee that it will become > available.

[https://help.yahoo.com/kb/SLN3060.html](https://help.yahoo.com/kb/SLN3060.html)

And make sure it doesn't get removed for inactivity:

> If you rarely use your account, it will go into an inactive state and then > be deleted. You can prevent this by signing in to your account using any > device at least once every 12 months.

<comment><USER4> I came here to say this. You _probably_ don't have old, forgotten accounts laying around with your Yahoo email address tied to them, but if you do, Yahoo reserves the right to hand over your password reset abilities to the next person who wants your username.

DON'T DELETE YOUR YAHOO ACCOUNT. Purge it of all content, sure, but flat-out deleting it is very risky.

<comment><USER5> I guess setting auto-reply with "I don't use this account anymore, please contact me via (either email or a link)." would do the job quite well.

<comment><USER6> Almost all commercial mails, including newsletters, past orders, discount offers based on purchases, etc., use an "unmonitored mailbox" or an invalid address to send information. Any reply, manual or automatic, will never get seen by anyone on the other side to take any sort of action.

The only way out is to trawl through one's account, hoping that at least one mail from each contact is available, and then changing the email address with each of those. For personal contacts, this would involve emailing them and hoping they see it. For commercial contacts, it would involve going to the respective site and figuring out how to change the address and confirm the new address. Overall, this would be a cumbersome process for many people.

</comment></comment></comment></comment><comment><USER7> >Update, 10/10/16, 5:30 PM ET –

Yahoo shared the following statement with TechCrunch:

"We're working to get auto-forward back up and running as soon as possible because we know how useful it can be to our users. The feature was temporary disabled as part of previously planned maintenance to improve its functionality between a user's various accounts. Users can expect an update to the auto-forward functionality soon. In the meantime, we continue to support multiple account management. "

The headline heavily implies it's permanent and intentional as an obstacle, which are not supported by available evidence.

<comment><USER8> But Yahoo only needs to stop people from moving away as long as they remember what Yahoo did, that memory is measured in days? weeks?

</comment></comment><comment><USER6> Since this is related to moving out of Yahoo, in a previous thread about the security breach at Yahoo, I had asked for suggestions on other email providers who're better focused on privacy, security (and related to that, freedom). I came across a few suggestions that support custom domains, but found all of them wanting in some ways:

1\. Fastmail - becomes very expensive if multiple people (say, in a team or family) want individual accounts even if their actual usage volumes are less. Pricing by user account is the barrier here, instead of pricing by usage (consider that it provides 600 aliases per user, which 99% of users wouldn't use to the full extent, but charges based on user accounts). Provides support for IMAP/POP, importing existing mails from other accounts and exporting mails out. A few hundred dollars a year for email is quite expensive for me.

2\. Protonmail - no way to import mails from existing mail accounts or to export mails from the system. The lack of support for IMAP/POP means one does not have the freedom to move out. Suggestions on these have been waiting for two years with nothing to show for. Pricing is somewhat similar to Fastmail, but offers more flexibility. This too could get very expensive even with lower actual usage per user.

3\. Tutanota - much better on flexible pricing based on different parameters, but it's similar to Protonmail in that it does not support importing existing mail or exporting mails out. It too lacks support for IMAP/POP and states that it's never going to support them for privacy reasons.

4\. Startmail - quite similar to Fastmail on the pricing issue, but has IMAP support.

Are there any other providers who do better on all these fronts? I'd like to use custom domains, have multiple user accounts (with separate credentials), preferably manage storage across users, be able to import and export mails, and have IMAP/POP support in order to use different systems (phones, tablets, computers with different operating systems). I don't believe that web mail and custom apps ought to be the only way to use email.

<comment><USER9> I'm pretty happy with Servermx [1].

It's hosted in EU, has IMAP/POP/ActiveSync (AS is not mentioned on website since it's still in beta, but has worked since last year reliably), Cal&CardDAV (CardDAV offers full HQ contact photos).

The prices are quite reasonable (1.8€ monthly for 10GB mailbox). Webmail interfaces are SOGo, Squirrelmail, Roundcube. Support tickets are answered instantly (couple hours).

You can migrate existing mail via an IMAP importer (logs into target IMAP server with your credentials and pulls email to servermx).

They offer a 30 day trial to check it out (without custom domain part for the trial), after that you can upgrade it to a full paid account, which supports custom domains.

[1] [http://servermx.com/](http://servermx.com/)

<comment><USER10> > They offer a 30 day trial to check it out (without custom domain part for > the trial), after that you can upgrade it to a full paid account, which > supports custom domains.

From their features page.

> With the trial product You can use your own domain name or use a free sub- > domain of servermx.com which will be assigned to you at subscription time.

Or did you mean they don't offer "Custom Web mail URL - Your domain name can be used for your web email client (example [http://webmail.yourdomainname.tld)"](http://webmail.yourdomainname.tld\)") during the trial?

Thanks for the heads up, I'll have to look into them as I'm getting bored of maintaining my own mail server and €24 isn't bad for a year. I'll have to look into them a bit more before taking the plunge though.

<comment><USER9> Oh, my mistake then, I thought the trial was only possible with their email address. Even better :)

</comment></comment></comment></comment><comment><USER11> This is why you should use your own email domain so you can just shuffle it around providers as needed.

<comment><USER12> For most providers, using your own domain is a paid feature.

<comment><USER13> I pay $5 a month for Google Apps, which is completely worth it for me since finding good, unclaimed short email addresses on Gmail is not possible.

<comment><USER14> If all you want is the email address, you can simply transfer your domain to Google Domains and use their free GMail integration. That'll save you $48/year assuming you don't value any of the other paid features in Google Apps.

<comment><USER15> I'd be afraid of Google's control over my domain name registration. Even if they don't do anything malicious, their "wall of silence" with respect to support leaves me very apprehensive. (Some people say it's different for paid- product support, but I don't know whether this includes $12/year domain name registration -- or will so in future.)

<comment><USER16> You can keep registration at your preferred provider, and set DNS for MX to Google, and there you go.

<comment><USER17> Can you please explain how exactly this going to work without Google Apps? Am I missing something?

<comment><USER11> Yeah, you're missing the bit where you use a 3rd party to send/receive the email as a proxy for your personal gmail account, i.e. using Zoho.

(1) Point your MX records at your Zoho mail

(2) Forward all mail from Zoho to your personal gmail account

(3) Setup a sender alias in your gmail account for your domain

<comment><USER17> This is way I using gmail now, but that is kind a opposite to statement in message I replied to: "set DNS for MX to Google".

Currently I have to redirect to Google and Google only send from those boxes using 3rd party SMTP server. So main advantage of having trusted sender is not there.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER18> I worked at a school helpdesk for a while, and I saw that whenever school email accounts were hacked, the attackers would set up forwarding to some other account. People wouldn't notice the forwarding for weeks or longer, and would only come in to us by chance. In the meantime, a lot of information could be siphoned off.

There could be some legitimate security concerns there, especially since most yahoo accounts don't have a convenient and free help desk to stop by, right?

(Disclaimer: I am only a novice when it comes to security, I could be totally off base)

<comment><USER19> There is a very easy solution to this, which I believe Gmail employs: Place a very noticeable banner on the inbox when all your email is being forwarded to another address.

<comment><USER20> I forward everything that _does not_ match a specific string using the filter feature in Gmail, and I get no such banner. It is a company owned email, with a custom domain and such, but should not differ in this case.

<comment><USER7> The banner only shows for a week after you set it up.

</comment></comment></comment></comment><comment><USER21> Gmail, on the other hand, has takeout which allows you to export all your mail in bulk if you want to leave and take it with you: [https://takeout.google.com/settings/takeout](https://takeout.google.com/settings/takeout)

</comment><comment><USER22> > (Disclosure: TechCrunch parent company Verizon is acquiring Yahoo.)

On the side:

> Verizon wants $1 billion discount on Yahoo deal | Crunch Report

Hmmm...

</comment><comment><USER23> Almost all mail providers offer some sort of mail collection feature via POP3 which can be used as an alternative to mail forwarding. The disadvantage is that you'll have some time delay (depending on how often your provider allows you to fetch mail). The advantage is that you aren't relying on any feature of the old mail provider. As long as it still provides POP3 you're all good - <USER2> I find it unlikely that yahoo will disable POP3.

(not saying this to justify Yahoo's rogue move here, but to give advice to people who have this problem)

</comment><comment><USER24> Just last week I noticed a charge on my credit cars from Yahoo Ad Free mail. There was an online link to cancel but no apparent way to request a refund.

I have no idea how I ended up getting signed up for this. I've long used Yahoo as pretty much a spam bucket when I have to give out an address to someone I don't care to get emails from. (For all I know, I somehow got signed up a while back but I certainly am not aware of doing it and it's not something I would normally have any reason to do.)

<comment><USER25> it is a scam not associated with yahoo in any way, i heard.

the credit card scammers just use the fact that almost everyone in the US has a yahoo email.

<comment><USER24> I was apparently signed up on Yahoo though as in I was able to log in to Yahoo and cancel the service. Which I assumed made the charge "legitimate" whether or not a refund was offered. I was thinking of disputing it but was inclined not to bother. Maybe I'll take a further look.

</comment></comment></comment><comment><USER26> We had a few customers complain to us that they couldn't forward customer support messages from Yahoo to Reamaze. Now we know why. Frankly, a very un- customer move by Yahoo.

<comment><USER27> Yeah I cant believe Yahoo would disable forwarding. People use it for other stuff, not because they want to move to another service.

This is going to make people want to move off Yahoo even more

</comment></comment><comment><USER28> I remember moving away from Yahoo! in 2008. It was like ripping off a bandaid, but after 3 months, I was able to stop checking it.

I replaced it with a personal domain with email hosting through gmail. Today, protonmail looks like an interesting alternative, and thanks to this setup, would be a painless transition.

<comment><USER29> I'd recommend FastMail. I've been using them for a while and I'm very happy with their service.

</comment></comment><comment><USER30> Gmail lets you export your Yahoo emails to itself. I did that once a long time ago and abandoned Yahoo altogether. You then just enable permanent vacation responder and be done with it.

</comment><comment><USER31> What a scummy move.

</comment><comment><USER32> No doubt they will try to find some way to further lock in Flickr users as well.

</comment><comment><USER33> Just another reason to never associate your real information with something like a Yahoo account, and always use different passwords for different sites.</comment>


What is the Nash Equilibrium and why does it matter? - <AUTHOR> http://www.economist.com/blogs/economist-explains/2016/09/economist-explains-economics <comment><USER2> If you find this article interesting, Coursera's "Competitive Strategy" [1] is a pretty good introduction on the topic of game theory and how it can be used as a decision-making framework for business, I've found.

As a case study, I recommend watching this episode of "Golden Balls" [2], which shows how a player can manipulate a game outcome and defeat the natural Nash equilibria. This is a classic IMO.

[1] [https://www.coursera.org/learn/competitivestrategy](https://www.coursera.org/learn/competitivestrategy)

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

<comment><USER3> I would like to recommend one more MOOC that covers different models (economic models, modelling people behavior, randomness, collective actions -Prisoner's dilemma, segregation models) and make you start thinking about the world in term of models.

[1] [https://www.coursera.org/learn/model- thinking](https://www.coursera.org/learn/model-thinking)

<comment><USER4> If anyone is interested in this course but would prefer to read a book instead, most of this class draws from "Micromotives and Macrobehaviors" by Nobel economist Thomas Schelling. The book basically serves as a compendium of different classes of models, and explores how counterintuitive behavior of the collective can arrive from perfectly reasonable and rational individual strategies of the actors.

It kind of reminds me of the explanation of how the crowd at the Hajj crush (on the front page earlier today) behaved more like a fluid than crowd of communicating agents because the human density was so high.

<comment><USER5> Thanks a lot for sharing it. I have just looked it up on Amazon and found that they say something like 'before Freaknomics ...'. What is the link between the two?

<comment><USER6> Freakonomics is a write up of several economics papers that used a statistical method called Instrumental Variables for causal analysis.

Schelling's book is a write-up of the theoretical predictions of several different game-theory models. I didn't notice much overlap between the two.

</comment></comment></comment></comment></comment><comment><USER7> Here's my boy's work on how to compute ε-Nash Equilibrium in large imperfect information games. It solved heads up limit Texas hold'em poker

[http://www.jeskola.net/cfr/](http://www.jeskola.net/cfr/)

You might also know Oskari as the author of Buzz Tracker

</comment><comment><USER8> Quote from OA

 _" In 2000 the British government used their help to design a special auction that sold off its 3G mobile-telecoms operating licences for a cool £22.5 billion ($35.4 billion). Their trick was to treat the auction as a game, and tweak the rules so that the best strategy for bidders was to make bullish bids (the winning bidders were less than pleased with the outcome)."_

I'm thinking best price for HM Government was paid by UK customers?

C.F. quote below from [1]

 _" The auction confrmed our view that industrial-organisation issues are more important than the informational issues on which the auction literature has mostly focused. In particular, the problems of attracting entrants and dealing with alliances and mergers are likely to remain major preoccupations of tele- com-auction designers for the foreseeable future. Tackling such problems sensibly requires high-qualit ymarket research that keeps pace with developments in an industry that can change its clothes with bewildering rapidity. We also need more theoretical work on the industrial-organisation implications of major auctions."_

(Basically the high bids lead to mergers & consolidation)

[1] [http://www.nuff.ox.ac.uk/users/klemperer/biggestpaper.pdf](http://www.nuff.ox.ac.uk/users/klemperer/biggestpaper.pdf)

<comment><USER9> FYI, the design of those auctions was led by Ken Binmore [1] who is one of the current leaders in game theory, and has done similar in other countries. People may find his publications useful reading on this subject.

I know Ken, he's exactly like you might expect a leading academic but is basically amazing (and very well liked by his students).

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

</comment></comment><comment><USER10> Quite disappointing that the article 'explains' the Nash equilibrium (NE) without going into details of how a NE is reached.

During my econometrics study this explanation helped me to explain it to others without going in to the mathematical details:

\- Person A needs to decide what the best strategy is for all strategies of B (circle, on paper, the outcomes for A)

\- Person B has to do the same (circle as well)

NE => look for 'box' (ie. outcome) that has two circles (there could be more!)

This leads to (confess, confess).

<comment><USER11> How well does this deal with the case when the optimal strategy is a mixed strategy?

<comment><USER12> It doesn't, because then you'd have to partially circle everything.

</comment></comment></comment><comment><USER13> Shout-out to the mythical man who founded the field of game theory, none other than Johnny von Neumann:

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

<comment><USER14> von Neumann's body of work is so impressive.

Anyone unfamiliar with him should at least glance at this _Known For_ section on Wikipedia. [https://en.wikipedia.org/wiki/John_von_Neumann](https://en.wikipedia.org/wiki/John_von_Neumann)

His body of work, breadth of scope, and reach of influence is really only comparable to Newton, Gauss, or Euler.

Edit: Can't forget Gauss.

<comment><USER15> Neumann is definitely the last true polymath, and in my opinion the greatest scientist of the 20th century. Coincidentally, I named my new PC at the university "vneumann" yesterday.

Don't forget Gauss - he has more contributions than any you've listed, and contributed to a vast number of fields. His 'known for' section is a separate Wikipedia page ;)

</comment></comment></comment><comment><USER16> The whole series on economics is pretty good reading:

[http://www.economist.com/blogs/economist- explains](http://www.economist.com/blogs/economist-explains) \- this seems to include some other stuff (which is doubtless interesting as well) but you can skip around to find the economics articles.

</comment><comment><USER17> Since it wasn't explained in the article, I went looking for what rules the British used to capture so much money from the 3g spectrum, and found this on Wikipedia:

> _The auction was conducted in a simultaneous ascending auction, similar to > the US format with a slight deviation. In the UK 's version of the > simultaneous individual auction, each high bidder is only allowed to win one > of the five auctions whereas in the US, many regions have multiple licences > which multiple bidders can win._

[https://en.wikipedia.org/wiki/Spectrum_auction#United_Kingdo...](https://en.wikipedia.org/wiki/Spectrum_auction#United_Kingdom)

</comment><comment><USER18> What's the difference between the Nash equilibrium and the Min-Max algorithm?

<comment><USER19> They are equivalent in zero-sum games, but not in non-zero-sum games. For example, consider a game between Alice and Bob who are sitting on a bomb. Each of them has three options:

1) Enjoy a nice latte

2) Trigger the bomb, killing both

3) Disarm the bomb, stopping the other from triggering it

The min-max strategy is to disarm the bomb, but there's a better Nash equilibrium where both players enjoy their lattes.

<comment><USER20> haha! That's an unusual example but I suppose it works.

</comment></comment></comment><comment><USER21> Isn't that a copy&paste of an article we discussed a few weeks ago? Of course it is interesting to see that the Nash Equilibrium comes to the same conclusion as natural instinct: When stuck in the prisoner dilemma you are F'd as well as the other guy.

But of course it's not the main application. If I remember correctly it is mostly used to find balanced solutions in complex inter-company or inter- government exchanges, considering each side's leverage as well as the assets' values.

</comment><comment><USER22> I'd recommend Dawkins' Selfish Gene for a good non mathematical introduction.

It really changed mine and lots of other people's worldview.

</comment><comment><USER23> When does the actual Equilibrium occur?

<comment><USER24> "When everyone in the group do what it's best for himself and the group."

EDIT: Irony is a class with enrollment restrictions.

<comment> proto-n No, not really. The nash equilibrium occurs when nobody is able to achieve a better outcome for him/herself when assuming that noone else would change their strategy with him (no coordination).

This is not neccessarily the best outcome for the market or the players themselves, see for example the prisoners dilemma (etc).

<comment><USER23> I don't see how that is helpful at all, that seams like useless information?

To me, i would look at it as a two dimensional plot somewhere there would be a statistical point which is the point of equilibrium.

Where these processes would statisticly end up.

</comment></comment></comment></comment><comment><USER25> prisoner's dilemma controls everything, no idea why Nash gets credit. it's human nature to create narratives like that sadly.

<comment><USER26> Nash didn't discover the Prisoners Dilemma, that system obviously has an equilibrium. What Nash did was prove that EVERY one of such systems has an equilibrium, regardless of what the details and weights of various rewards and penalties (etc) are.

<comment><USER27> It is only in the space of "mixed strategies" that there need be an equilibrium. And in many (most?) cases it is not at all clear how a mixed- strategy equilibrium might come about. Therefore Nash's result is more limited than it might at first sight appear.

The Economist's full article (behind the paywall) in fact repeats this claim that I consider misleading: "Nash showed that every 'game' with a finite number of players, each with a finite number of options to choose from, would have at least one such equilibrium."

An equilibrium that does not depend on the notion of mixed strategies is called a pure-strategy equilibrium. For an example of a game that has no pure- strategy equilibrium, see [https://en.wikipedia.org/wiki/Matching_pennies](https://en.wikipedia.org/wiki/Matching_pennies).</comment></comment></comment>


Inside Uber's Auto-Lease Machine, Where Almost Anyone Can Get a Car - <AUTHOR> http://www.bloomberg.com/news/articles/2016-05-31/inside-uber-s-auto-lease-machine-where-almost-anyone-can-get-a-car <comment><USER2> Will say this: my uber drive yesterday was fed up. He's moving back to his home in Afghanistan.

Current lease payment for him through this program: $250/week - I can see why.

</comment><comment><USER3> off topic, but I've noticed that they're now straight up lying to people using adblock...

"We noticed that you're using an ad blocker, which may adversely affect the performance and content on Bloomberg.com."

Pretty sleazy, bloomberg.</comment>


Documentation is King - <AUTHOR> http://kennethreitz.org/open-source-and-constraints.html <comment><USER2> I've been doing some experiments to improve recall of documentation.

So far i've learned a few seemingly effective techniques:

1) Occasionally construct some weird sentences, throw grammar out the window for a sentence (any longer doesn't work) and people will recall that whole section of the document, months, even years later. I have no idea why this is so effective, but i'd love to know.

2) State an assumption and have it missing the obvious consideration. Don't make it some intricate detail, it has to be in plain sight even for someone not familiar with the topic. Again, people recall these sections and are happy to suggest how you could improve the document.

3) Never tell anyone you're playing tricks like this, it completely loses its effectiveness when people know what you're doing with the slightly strange documents.

4) Test the recall of others frequently on your text. Probe them and figure out what's easy to remember and what's not. You can use this to tweak your documents for future.

5) Don't over use it. The goal doesn't have to be to have them remember everything, but it must allow them to remember where they found the information previously.

YMMV, but i'm blown away so far and i haven't seen anyone talking about this along similar lines yet. It all started after reading one too many psychology books.

<comment><USER3> You broke (3) with this comment!

Similarly, there's some research that less-legible text is recalled better: [http://bps-research-digest.blogspot.com/2010/12/harder-to-re...](http://bps- research-digest.blogspot.com/2010/12/harder-to-read-fonts-boost-student.html)

Compare also bloggers who intentionally oversimplify and make small errors in their headlines/articles, guaranteeing more attention via outrage-forwarding, a vibrant comment section, and 'hook' for a followup post that extends/clarifies/apologizes.

Strightforwardness is good for many things... but not memorability.

</comment></comment><comment><USER4> I agree with this, but have had trouble getting support for the idea of focusing on documentation among my coworkers. The major concern is that comments can rot as code changes and the comments/documentation are not updated to reflect the changes.

It's my opinion that it should just be part of the developer's discipline to update documentation as they update code, but this seems not to be practical when not everyone shares my idealism for documentation. What ways are there to get buy in from those that need to be convinced about the value of documentation?

<comment><USER5> Documentation is part of engineering. Hire engineers rather than two bit coders. They already have the culture burned in.

Works for us. Most people not up to it I.e. find it boring or can't put a sentence together bail in a month because they can't get their code through the review cycle. They are made well aware of the requirements at interview time.

We're in financial sector so sound engineering and documentation stops us getting in deep shit.

Case in point recently, one of our service providers broke their service API silently. We had their documentation, contracts etc set in stone in source control, named and dated as were our integration paths. When they pointed the finger at us, we were covered.

The small detail was recorded (1 penny rounding method) which meant we could trace it instantly, pop open our log4j dumps and found that they sent the value wrong. Not only that, we raised it to start with because our constraints were documented and assertions were in place.

</comment></comment><comment><USER6> I always wondered if great tools like vim, nmap, git, etc. are successful because they have great documentation, or have great docs because they are successful.

maybe the answer is in the middle and above, great tool makers are great docs writer.

<comment><USER7> Its amazing how most manpages are better written than the average paper from academia or product manuals.

<comment><USER8> Papers from academia present new results in a specialist area. It's not surprising that they will be less readable and contain more jargon than a manpage. The latter is intended to show how to use something for the general computer user, not how it manages to do it. Furthermore manpages have the chance to undergo many revisions, papers generally do not.

<comment><USER6> > It's not surprising

Being "not surprised" seem to be the new meme on HN. Anyway, let me disagree: when you know how to write words in a sentence, you do it well under any circumstances. (I forgot its name but there is a story of this British poet whose one-sentence instruction sticker on how to handle the toilet flush was such a precise and cristalline piece of prose)

So no, if academic papers are so poorly written now compared to manpages or academic papers centuries ago, it is because academic people are worse writers.

</comment></comment></comment></comment><comment><USER9> I am becoming fascinated by finding better ways to document and communicate about code - not just writing good docs as part of checkin but, well lets say we take on a feature.

We should propose how to implement that feature, (spec) get some feedback, go do it, review the implementation against the spec and even then I would want to have a sort of stack overflow Q&A site so people can ask why did you do that ?

Anyone else feel we are missing a whole boatload of tricks?

<comment><USER10> When working on or editing documentation or the comments, I start with the "two-year-old kid" review. I ask myself "why" and "what", and often repeatedly, until I get to a concise answer.

What's this? Why is this here? Why do I want it? Why is this good? Why do I care? Why? What's that mean? What's this knob do? What's that code do? Why is this code here? Why?

Flabby documentation, user documentation written in programmer jargon and scatter-shot code comments are all comparatively easy to write. When somebody bothers to write that.

Writing for the end-user (whoever that might be) is tougher, and I find require iterating on the content of the documentation, UI, release notes, comments, or whatever. Writing less documentation or fewer comments — while conveying the necessary details — is hard work.

</comment></comment><comment><USER11> Every time I face a rant like this at work, I need only fire up an editor and pull up the source code to git. For loads of fun, load up date.c. There is no disputing that git is high quality code that we rely on. My dispute is that odd insistence on rigid documentation standards is silly in this context.

Note, this is not to say that documentation doesn't matter. It definitely has a prominent role. So does "does the job." Preferably well. The blogger mentions a prime lens works because it doesn't allow zoom. Sure it does, you just have to move your feet. This can actually be rather annoying when you are trying to get a candid shot in the house. Framing doesn't automatically happen with a prime lens, that is. However, the quality of image from a prime is huge. More than makes up for the short comings for many of us.

</comment><comment><USER12> Producing great documentation requires the same kind of judgement as designing the system in the first place: if you can consistently put yourself in the mind of your reader, then your code, your APIs, and your documentation will all be much better.

More documentation is not necessarily better. Just like code, the best documentation is the documentation you never had to write because you found a simpler way, and eliminated the issue completely.

</comment><comment><USER13> Hey Kenneth, I saw your tweet about wanting a .org for your website. Any reason for the migration to a .org?

<comment><USER14> If you saw it on twitter, why don't you ask this on twitter?

<comment><USER13> I am lazy.

</comment></comment></comment><comment><USER15> Its pretty old, but its hard to get better then Doxygen: <http://www.stack.nl/~dimitri/doxygen/></comment>


Innovators Dilema - Applying it to Apple - <AUTHOR> http://mayanks.blogspot.com/2010/05/innovators-dilemma.html

<comment><USER2> The major point in Clayton Christensen's book is that existing/old companies are way too used to high margins (and low/median volume) on their products. Think mainframe computer vendors versus PCs with 64 KB ram: it requires a different kind of company to survive on a Dell margin than on a mainframe margin. Christensen's point is not that new technologies requires new skills, as (technological) skills are much easier to get than to transform a company financial structure/culture.

Apple was used to high margins and low volume. Steve improved the product selection when he returned by simplifying it and thus reduced costs, something very few companies are able to. He made it focus, and made it able to produce things cheaper. This was the most important change of Apple that he made.

Both iPods and iPhones started out as low volume / high margin, and as such fitted very well into how Apple operated.

Nokia has lower margins, so in theory they should have been much more likely to get the mp3-player marked (if they had ever tried). Funny Apple should be able to undercut a company that has lower margins. But Apple was able to reduce costs. So therefore Apple got to keep the market share instead of loosing it when the market prices went down. Had the iPod still been the $500 mainframe-like price, Apple would have had Mac-size share of music players today (single-digit percentage) instead of the lions share.

And Apple (i.e. Steve Jobs) has 2 very important qualities that cannot be copied even if you have all the money of Microsoft:

a) good connections to the music industry so he could get iTunes Store at a time where e.g. MS failed to get deals as good as Apple's. He had _the trust_ of music executives. You cannot buy trust, only temporary friends, and as Machiavelli told us, no friend is as untrustworthy as the one you buy for money.

b) taste. Look at how badly the US car makers have done after they lost the taste they had in the 50's and 60's. Producing cars more cost effective is much easier than getting the board to hire a CEO with taste. Most car buyers prefers to pay for good design more than for functionality, so when the US cars lost the "wow" factor, then they were delegated to the Dell end of the scale and they have trouble building cars at this price level without loosing money. Taste is what made OSX, iPhones and iPads "just work" and look beautiful at the same time instead of being just a Windows Vista lookalike. Blond with brains and money.

And Apple has Tim Cook to run the operations. So they could lower the price as the market price went down. The competitors can't even sell their iPad killers for _significantly_ less than the iPad (and they don't even have an app store). Practically same price for less product is not how you dethrone the market leader.

Everything comes from the people you have. That is the fundamental competitive advantage that Apple has.

<comment><AUTHOR> Nice summary. Completely agree to your points. The reasoning of value network may not directly apply to Apple, but yes Nokia was in the right position to make as much impact if not better than what Apple did with iPhone.

</comment></comment><comment><AUTHOR> I am looking for any other examples where a company has successfully migrated to the next technology S curve. Any examples?

<comment><USER3> The currently much maligned Nokia started making wood pulp, then moved to rubber, then to electronics. IBM's transition from mechanical tabulating machines to mainframes and minis should count. Nintendo went from making playing cards to arcade games to home consoles.

In fact most companies that has been around for more than 50 years have probably had to make at least one or two such migrations just to survive.

<comment><AUTHOR> I wouldn't consider Nokia as having adapted to disruptive technology. I think Nokia's example is similar to 3M's. IBM may be a right candidate, but I wouldn't agree that it has adapted to disruptive change. Yes it has survived through it.</comment></comment></comment>


Horror Fans Have More Fun During a Pandemic - <AUTHOR> http://nautil.us/issue/87/risk/horror-fans-have-more-fun-during-a-pandemic <comment><USER2> Very cool. I'm not a super big horror fan, but when this whole pandemic thing started, I consciously went on a ~2 month horror binge for fun, watching a bunch or horror films (of varying quality) and games. Now I wonder if there was something subconscious about that.

Might've damaged my psych though....</comment>


Tap tap tap - design process - <AUTHOR> http://www.taptaptap.com/blog/the-design-session/

<comment><AUTHOR> Interesting use of Skitch - one of my favourite and most used apps.</comment>