Amazon Apologizes For 'Embarrassing And Ham-Fisted' Gay Book Blacklist - <AUTHOR> http://www.businessinsider.com/amazon-reverses-course-apologizes-for-embarrassing-and-ham-fisted-gay-book-blacklist-2009-4

<comment><USER2> So then is the supposed hack by 'weev' false?

<http://news.ycombinator.com/item?id=560075>

</comment><comment><AUTHOR> I think the more interesting story might be the role Twitter played in all of this.

<comment><USER3> What impact did Twitter really have? I'm annoyed with all of the constant Twitter hype -- I think it's overblown and that there's not much behind the fad. It seems like a case of everyone jumping on the bandwagon to me, especially in the cases of MSM; they're just desperate to be on the brink of the next big thing, and so everyone jumps all over Twitter not because they appreciate Twitter but because they're all trying to be cooler than each other. Twitter is pretty lame, and it's pretentious, and I don't like it, and I don't think that many other people do either. So, is Twitter really significant here or is this just another case of wannabe hipsters attempting to appear clairvoyant so that everyone will complement their impeccable fashion sense?

<comment><USER4> I keep hearing Twitter bashing on this site and it's starting to bother me. Twitter is what you make it. It all depends on who you choose to follow. It's perfectly fine if you haven't found a way to make use of Twitter, but for an increasing number of people, Twitter is starting to play a pretty important role.

I dropped my cable subscription when I moved to my new apartment last August and outside of HN I've been relying mainly on Twitter to hear about what's happening in the world at large. I've used it to communicate with friends and coworkers, to see what interesting people in the open source community are doing, to communicate with people during conferences such as at PyCon, to ask for help and to help others, and for entertainment.

Yes, there's plenty of hipsters and social media experts that do nothing more than add noise, but the asymmetrical follow model and the ease to start and stop following people means that you shouldn't care. Choose the people you find interesting and it will make all the difference.

<comment><USER5> _I dropped my cable subscription when I moved to my new apartment last August and outside of HN I've been relying mainly on Twitter to hear about what's happening in the world at large._

That's just a stupid thing to say and exactly the kind of hype that's getting on our nerves (speaking for us, the twitter immune here).

My opinion towards twitter as a technology is fairly ambivalent - It's a horrible implementation but as long as I'm not forced to use it I couldn't care less.

What's annoying is all those people who feel a need to cite the medium as if it added any kind of value to a message.

<comment><USER4> "That's just a stupid thing to say and exactly the kind of hype that's getting on our nerves"

When making statements of that nature you should rely try to elaborate more. What exactly is a stupid thing to say? Claiming that I rely on Twitter as a source of news? Why is that stupid? I've been doing this since August and it's worked out really well so far. I'm not trying to convince anyone else to do the same, I was just responding to a question of whether or not Twitter provides actual value. To me it does.

The medium does not provide value to the message, but it does provide a very powerful way to spread messages and to organize people. What alternative communication medium would you recommend for organizing a protest? (Like the one that happened in Moldova [http://neteffect.foreignpolicy.com/posts/2009/04/07/moldovas...](http://neteffect.foreignpolicy.com/posts/2009/04/07/moldovas_twitter_revolution))

<comment><USER6> You're not "relying on Twitter" for a source of news, you're relying on unattributed hearsay which just happens to be transmitted through Twitter.

That's not smart.

<comment><USER7> How do you know who he follows?

<comment><USER8> Half a dozen clicks from his HN profile and you're there: <http://twitter.com/offbytwo/friends>

<comment><USER4> Impressive, I updated my profile so it should be easier to find now.</comment></comment></comment></comment></comment></comment></comment></comment></comment>


Show HN: 2,469 Remote Companies Hiring in 2020 - <AUTHOR> https://remotehub.io/ <comment><AUTHOR> Hello HN!

I've been working on a website about remote work for almost 2 years now and I feel I'm still searching for my angle. Maybe you can give me some advice?

1\. I know there are a lot of remote job boards out there and I see no point in building just another one.

2\. It needs to be something different! I first started with a list of remote companies: [https://news.ycombinator.com/item?id=19444960](https://news.ycombinator.com/item?id=19444960)

3\. But then built a lot of stuff. If you're curious, I list almost all my features here: [https://remotehub.io/sale](https://remotehub.io/sale)

4\. And now I'm thinking about putting the focus again on the companies – started to surface teams on the front page every day.

5\. I think I have some interesting data about companies, like their remote team locations, benefits they offer, remote work tools they use etc that can be useful when looking for a team to join.

What do you think, how can I make it useful for _you_? Are you interested in discovering remote companies like this?

– Rauno (raumet.com)

<comment><USER2> This is also coincidentally a good list of quality software companies. I recognize a few that I use from the list: Ghost, Shogun ;)

Focus on the skills, rolls. Teams that don't just work remote, but "async". Fractional work. App development that can be sub-contracted to a dev shop, in lieu of full time hire. Shops can specialize in particular categories such as "next-gen dart / flutter"

<comment><AUTHOR> Cool, thanks!

</comment></comment></comment><comment><USER3> You should just remove the annoying link at the bottom right which follows you around even if you scroll. There is already an about page in your site, thus I can easily find who you are if I care.

<comment><AUTHOR> It annoys me too! Removed.

</comment></comment><comment><USER4> I see lots of ways to filter out companies, but no way to see jobs for all of them - or at least it does not seem obvious to me.

<comment><AUTHOR> Similarily to /remote-companies page there's /remote-jobs page that has the same filters: [https://remotehub.io/remote-jobs](https://remotehub.io/remote- jobs)

You can find "Remote jobs" link from the top menu, but maybe it's not very visible.

Would you rather see jobs on the front page instead of companies?

<comment><USER4> oh nice, I completely missed!

Yeah, I would prefer that personally, but maybe it's just me haha.</comment></comment></comment>


Is Clojure the "New Lisp"? - <AUTHOR> http://www.lunaticprogrammer.com/2009/02/is-clojure-lisp.html <comment><USER2> Shrug - call me a critic, but this is another "Why I think Clojure will be good" article, rather than one with some (new) substance.

I'd like to see some more articles on Clojure in actual practice.

(p.s. It's because it's built on the JVM).

<comment><USER3> Clojure in practice: <http://news.ycombinator.com/item?id=494147>

</comment></comment><comment><USER4> I sure hope so More acceptance of functional programming is always a good thing. I love coding for in Lisp but I haven't really made the leap to production code since I have to support 4 platforms with all code I write for work (Windows, Mac OSX, Linux on x86, Linux on ARM), and deploying Lisp code across all those platforms auto-magically reliably SUCKS. We write all our stuff on the JVM so this would be easy to bolt on and expose to new people.</comment>


John Battelle reveals adsense revshare split - <AUTHOR> http://plentyoffish.wordpress.com/2007/04/05/john-battelle-does-deal-with-google-and-reveals-adsense-revshare/ <comment><USER2> Here's his original source. <http://valleywag.com/tech/lazy-valleywag/spying- on-federated-media-250003.php>

With only a handful of people on the conference call FM must have sent out the clip on purpose to help recruit new publishers. The call was back in Feb and they said once they have permission from Google to let the world know they are getting a better deal than smaller publishers, they would get the word out. This could be their sneaky way of doing it.

</comment><comment><USER3> Did anyone copy this before it disappeared?

<comment><USER4> I call the bullshit on this.

It's 51 minutes of silence. Anyway I've put it up if anyone can hear anything: <http://www.ijigg.com/songs/DC0DEDAPA4>

Late April Fools? Gosh I hate this month.

</comment></comment><comment><USER5> Link is dead.

<comment><AUTHOR> I hate it when he does that... Markus sometimes likes to take down posts after a few hours. There was a great article he wrote about botnets and DDoS that came down within 15 minutes.</comment></comment>


Jack Ma and Elon Musk debate at the World AI Conference - <AUTHOR> https://www.facebook.com/bloombergbusiness/videos/484701878927313 <comment><USER2> YT link (in case you want to avoid FB): [https://www.youtube.com/watch?v=uJ5w11Cm3gM](https://www.youtube.com/watch?v=uJ5w11Cm3gM)

</comment><comment><USER3> Can't tell what was bigger: language barrier or cultural one?</comment>


How and Why Computers Roll Loaded Dice - <AUTHOR> https://www.quantamagazine.org/how-and-why-computers-roll-loaded-dice-20200708/ <comment><USER2> Weird -- it appears to be missing the last 10-20 years of development in random numbers by the data science and cryptography community. They have put a lot of work into it.

If I recall correctly there are two major angles, 1\. there is an instruction in modern Intel chips that samples random thermal noise. 2\. there are a whole class of elliptical curve approaches that pass a bunch of randomness tests.

And I'm just scratching the surface here.

<comment><USER3> So this is not what the article is about.

It discusses a new method to generate integer values according to an arbitrary probability distribution, using as input a uniform random generator. Whether the input generator is truly random, pseudorandom, cryptographically secure etc, is irrelevant: the output will presumably only be as random/secure as the input RNG.

Admittedly, the article does a poor job at explaining what the FLDR method is about, and it looks as biased as the method itself (sorry for the easy pun). From my understanding of the paper [1], the method is better than the state- of-the-art Alias method [2] only when the entropy of the target distribution is low. When entropy is high, it performs similarly (or may even be a bit slower) but uses up to 8 times more memory space.

[1] [https://arxiv.org/abs/2003.03830](https://arxiv.org/abs/2003.03830)

[2] [https://en.wikipedia.org/wiki/Alias_method](https://en.wikipedia.org/wiki/Alias_method)

</comment></comment><comment><USER4> This article is a bit rough around the edges, and they really should make it clear when they mean "pseudorandom" vs "random", especially when one goal of the article is ostensibly to explain pseudorandomness to laymen!

As an aside, using a source of random numbers to generate other random objects is quite an interesting problem! For converting from one probability distribution to another, we have classical methods like rejection/importance sampling, and modern deep learning makes constant use of the "reparameterization trick" [1,2]. Looking beyond just numbers, here's a neat trick for generating a random orthogonal matrix:

      A = np.random(n,n)
      Q,_ = np.qr(A)

With a small correction [3], we can guarantee that our samples have uniform distribution (Haar measure) on the space of all orthogonal matrices:

      def haar_measure(n):
        # naive method
        Z = randn(n,n) + 1j*randn(n,n) / np.sqrt(2);
        Q,R = np.linalg.qr(Z);
        # correction
        d = np.diag(R);
        PH = np.diag(d) / np.absolute(d);
        return Q @ PH;

For more, read about random matrix theory! As an exercise for the reader, how would you generate: a random symmetric matrix? a random skew-symmetric matrix? a random positive-definite matrix? a random hamiltonian path in a fixed graph?

[1]: [http://gregorygundersen.com/blog/2018/04/29/reparameterizati...](http://gregorygundersen.com/blog/2018/04/29/reparameterization/)

[2]: [https://timvieira.github.io/blog/post/2014/07/31/gumbel- max-...](https://timvieira.github.io/blog/post/2014/07/31/gumbel-max-trick/)

[3]: [http://www.ams.org/notices/200705/fea-mezzadri- web.pdf](http://www.ams.org/notices/200705/fea-mezzadri-web.pdf)

</comment><comment><USER5> Modern computers have some sources of entropy that can be used to create a random numbers. For example, the timings of the memory access, race condition of threads. User interaction (mouse movement, delays between keystrokes) can also be used as an input signal to feed a random number generator (which is some hashing algorithm).

</comment><comment><USER6> > Pi itself is not a random number, for example, but the digits of pi are > believed to be random in this way (what mathematicians describe as > "normal"): Every integer from 0 to 9 appears about the same number of times.

Does this not make the digits of Pi discreetly distributed (an equal chance for each integer?)? Is the meaning of 'normal' here not referencing a normal distribution?

<comment><USER7> Normal has myriad uses in mathematics. See [1]. Somewhat annoyingly there is no common thread to their meanings (Or at least not one that I am aware of).

The article intends normal number, not normal distribution.

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

<comment><USER8> > Somewhat annoyingly there is no common thread to their meanings

The common thread is the Latin word "norma" for a carpentry square. This gets taken literally in cases like "normal vector", figuratively in cases like "Euclidean norm" (i.e. to measure) then increasingly distant as the word is a root to mean usual/ordinary/average (i.e. according to standard measure) in many languages and thereby ends up in "normal number", "normalized vector", etc. "Normal distribution" inherits it doubly, Gauss used it in the orthogonality sense and later authors in the ordinary sense.

</comment></comment></comment><comment><USER9> I feel like it's leaving something out. Some major advance in RNGs is just based on padding the possibilities so they're a power of two and throwing out the "padding possibilities" if they come up?

</comment><comment><USER10> It seems comical that our idea of randomness is so specific</comment>


Show HN: Link My Photos: Add Links to Your Instagram Photos - <AUTHOR> https://linkmy.photos <comment><USER2> Didn't get it. Found your ig profile. tried it. seems very un-intuitive. not sure people will understand it or go through all the trouble. [See Image -> goto profile -> click link in profile -> find image again -> click image -> go to website]

I feel like something that simply 302'd the user to the most recently posted URL would make more intuitive sense, but with obvious drawbacks.

<comment><AUTHOR> Thanks for the feedback @asteadman! We might consider featuring the most recent photo more prominently because that's the most common use case, but we don't want to confuse the user by sending them to specific content without context. That's the issue with just directly linking to the most recent content in your bio. Older photos with "link in bio" in the caption get sent to the wrong destination. Maybe we can offer the single redirect as an option to the user. Thanks again for checking us out!</comment></comment>


Show HN: Collect Azure/Office 365 IP using Azure function - groovy-sky https://github.com/groovy-sky/azure/tree/master/func-parse-cloud-00#introduction <comment> groovy-sky Functions code is available here - [https://github.com/groovy-sky/azure- office-ip](https://github.com/groovy-sky/azure-office-ip)</comment>


Show HN: FPP, a powerful 'tinkered' version of Firefox Portable - <AUTHOR> http://justatinker.com/index.html#FPP

<comment><AUTHOR> Folks:

Firefox Portable Plus (FPP) is my attempt to finally make a version of Firefox Portable that is independent of the host computer. VLC Media Player is completely integrated into the installation so that it will play most audio and video formats embedded within a tab in Firefox. Adobe Shockwave Flash is also built in and FPP will ignore any versions installed on the host computer. There is also the option of using Java through JPortable from portableapps.com.

I have 'hand tweaked' the skin and added over 40 extensions into FPP to make the 'look & feel' of the browser is esthetically pleasing as well as being intuitive and functional. I've also made dozens of the most popular 'under the hood' tweaks through 'about:config'.

This is a public version of the web browser that I use every day. Instructions on it's use, it's many, many features and how to modify it yourselves can be found on its web page.

tinker

</comment><comment><USER2> Pretty sure you can't re-post this

<comment><AUTHOR> smt88:

Apologies, I'm new to HN. I couldn't figure out how to post and then, when I noticed the 'Show HN' feature, I couldn't delete my other misplaced posting.

Is this the wrong sort of thing to post at all? It IS something folks would have a lot of fun playing with. I read the requirements, I just didn't know about 'Show HN', is all.

tinker</comment></comment>


Intel shows off its Knights Corner one teraflops chip - <AUTHOR> http://www.bbc.co.uk/news/technology-15758057

<comment><AUTHOR> Interesting to see the Larrabee work finally pay off. It's 50 simplified x86 chips, performing work entirely in-order.

So while it will run code written for normal x86 chips it will run better if you write it specifically for this architecture.</comment>


Sn0wd3n: the Game - <AUTHOR> http://sn0wd3n.com/

<comment><AUTHOR> Edward Snowden's mission is to educate the public about the privacy violations commited by the government with their mass surveillance programs. To continue Snowden's mission, we'll create sn0wd3n - an adventure game that will be made available for free and accessible through the Web and mobile.

<comment><USER2> As part of that you could gamify the installation and use of various tools.

"Download Tor - 50 points!"

"Create a GPG / PGP key? 50 points!"</comment></comment>


The 32-Bit Dog Ate 16M Kids' CS Homework - <AUTHOR> https://news.slashdot.org/story/17/01/22/1940249/the-32-bit-dog-ate-16-million-kids-cs-homework <comment><USER2> Hah. They used unsigned int32 to store index of coding things. They didn't realize they were reaching 4 billion ish. Went over.

Now index is saved as uint64</comment>


When Will Covid-19 End? Data-Driven Estimation - <AUTHOR> https://ddi.sutd.edu.sg/ <comment><USER2> Interesting estimations, but the phrasing of COVID-19 "ending" seems a bit counter-intuitive. I have read many experts claiming that it's more or less certain that the virus, due to its prevalence, will join the arsenal of commonly occurring flu viruses and come back on a yearly basis. WHO stated just the other day that there is "no proof" that being infected with COVID-19 creates immunity against a second infection.

With so much insecurity and no vaccine in sight, I think one should talk about the "end" of this virus in very careful terms, and perhaps talk about the end of the current pandemic instead.</comment>


CommitBeat: "Generate small sequence of music from commit SHA" - <AUTHOR> https://github.com/maxwellito/commitbeat <comment><USER2> This is the best thing I have seen, EVER.

It's amazing when you find a commit with a relaxing tune.</comment>


Reading Simple Haskell - <AUTHOR> https://soupi.github.io/rfc/reading_simple_haskell/ <comment><AUTHOR> Unrelated: I'm obviously quite biased, but I generally like Haskell code for pseudo code like things, because it does away with a lot of syntax specific cruft, and stays close to the math it's usually talking about.

Also, readers might be interested in A Tour of Go in Haskell, which is the concurrency chapter of A Tour of Go, but just...in Haskell - [https://a-tour- of-go-in-haskell.syocy.net/en_US/index.html](https://a-tour-of-go-in- haskell.syocy.net/en_US/index.html).

<comment><USER2> Go is impoverished compared to Haskell but not when it comes to concurrency. The Haskell analogues for these concurrency primitives seem laborious...and they were even moreso prior to the advent of the `async` library.

<comment><AUTHOR> A commenter on /r/haskell[0] noted that there is actually a library that mimics Go Channels a bit closer, called GoChan[1]. That said, I think `async` is the idiomatic choice, so it probably makes more sense to keep it.

[0] [https://www.reddit.com/r/haskell/comments/7ilhb9/a_tour_of_g...](https://www.reddit.com/r/haskell/comments/7ilhb9/a_tour_of_go_in_haskell/)

[1] [https://hackage.haskell.org/package/gochan-0.0.2/docs/Contro...](https://hackage.haskell.org/package/gochan-0.0.2/docs/Control- Concurrent-GoChan.html)

</comment></comment></comment><comment><USER3> This site breaks the zoom function in Firefox.

Please be considerate towards the visually impaired, and don't break zoom on one of the few browsers that actually even have a somewhat useful zoom function!

<comment><USER4> While I agree STRONGLY, I just tested after seeing your comment and it led me to try the Reader mode in FF which worked perfectly and thus allows full zooming of this site.

<comment><USER3> Wow, thank you for introducing me to that feature!

</comment></comment></comment><comment><USER5> Haskell can be very readable and elegant, but what I do find frustrating is when research papers show sample Haskell, but it's not quite Haskell. They just can't seem to resist the urge to replace various operators and types with their own non-alphanumeric symbols, thus making what should be reading simple code into some kind of hieroglyphic translation exercise..

<comment><USER6> > when research papers show sample Haskell, but it's not quite Haskell

For the most part the code in the research papers actually _is_ valid Haskell, provided you enable the -XUnicodeSyntax extension and include a few extra modules. Haskell 98 permits Unicode symbols and identifiers; the extension covers the handful of symbols which are built in to the language or enabled by other extensions. You can find a full list here: [https://downloads.haskell.org/~ghc/latest/docs/html/users_gu...](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#unicode- syntax)

Personally I prefer Unicode symbols and tend to use them whenever possible. I have some XCompose rules configured to make them easier to type. Unfortunately, I have yet to find a comparable input system for Windows.

</comment></comment><comment><USER7> One thing this doesn't mention, which might be useful to know, is that Haskell is indentation-sensitive. For instance, those examples using "let" won't compile if the lines beginning with "let" and "in" aren't indented.

I'd be interested if anyone knows of a simple guide to Haskell's indentation rules - I still find it trips me up now and then.

<comment><USER8> > Haskell is indentation-sensitive.

That's not really true, at least not in the way Python is. Haskell is actually defined using "braceful" syntax, and that syntax can be used anywhere (and is useful for code generation); on top of that it has Layout Rules[0].

Basically:

Any time a "where", "let", "do" or "of" keyword is not followed by a brace, an implicit one is inserted and the indentation of the next lexeme (non-comment non-whitespace item) is noted[1]

For any subsequent line,

* if it's indented by the same amount as the one noted, a semi-colon is prepended

* if it's indented by less than the noted amount, a closing brace is prepended

A closing brace is also inserted when encountering an illegal lexeme (for the current structure) where a a closing brace would be legal.

[0] [https://www.haskell.org/onlinereport/haskell2010/haskellch2....](https://www.haskell.org/onlinereport/haskell2010/haskellch2.html#x7-210002.7)

[1] _except_ if the indentation of the next non-whitespace lexeme is less than the current indentation level, then an empty block is inserted, and layout processing for the current scope continues

<comment><USER9> Internally, Python is a lot like that, too - like in Haskell, the lexer adds in brace tokens when the code is indented an unindented, which keeps the grammar simpler. I guess the main difference here is that Haskell exposes the underlying whitespace-insensitive notation to the programmer, too, whereas Python keeps it hidden.

<comment><USER10> Haskell is also a LOT more lenient. So stuff like

        if x < 5
        then 42
        else x
           + 1
           + 2

is legal.

</comment></comment></comment></comment><comment><USER11> I once downloaded a python script, ran it with some input, and got a result. Curious, I opened the script in Emacs, which then opened it into python mode. As is my habit, I indented the whole file, which did basic white space changes to it according to python mode. I didn't realize I did this at first, and I saved and exited the script, then played around with it some more. Still got results, everything seemed the same. But when I tried it with the same input as originally, it was a different return result. This took a while to figure out, until I realized that emacs changed the indentation of just one line, because the author had apparently not followed the typical idioms or conventions of indenting python in some way. That merely opening, beautifying, and saving a file could change program output with no errors has turned me off of white space sensitive syntax ever since.

Which is partly why OCaml gets some bias from me over Haskell.

<comment><USER12> You used a buggy beautifier that mishandled some code, and you blame significant whitespace?

For that to be valid criticism, it must be particularly hard to write a beautifier for languages with significant whitespace relative to other languages.

I don't think it is. Beautifying C, for example, also can be tricky in the presence of nested comments (potentially of different types) and nested _if_ statements, some without _else_ clauses, some without {}.

<comment><USER13> _Beautifying C, for example, also can be tricky in the presence of nested comments_

C comments do not nest.

<comment><USER14> Since C99, you've been able to have end-of-line comments inside a block comment.

</comment></comment></comment></comment><comment><USER15> I've always been confused when reading Haskell snippets on the web, this really cleared things up for me!

</comment><comment><USER16> Haskell is one of the few major languages I haven't used much. I find this to be very helpful. Sometimes I look at the Pandoc source and wonder what the hell I'm looking at.

</comment><comment><USER17> I like the content but:

I can't link to the slide because of the way these pages are defined:

slide 11: The presented argument order in the ASCII-art of Red, Blue, Green I think should be Red, Green, Blue to match the usual initialism.

I could not find a way to submit a pull-request for this presentation, and my search-fu on github failed to find the associated repo, and there were no links I could find in the presentation to submit comments.

<comment><USER18> Thanks! fixed.

You can find the document and repo here:

[https://github.com/soupi/rfc/blob/master/reading_haskell.md](https://github.com/soupi/rfc/blob/master/reading_haskell.md)

</comment></comment><comment><USER19> I only started Haskell since the 1st day of Advent of Code this year. I didn't see that mentioned much either in the article or other articles, but Haskell is like Python and has significant whitespace to determine scope. The error messages related to this aren't always clear...

<comment><AUTHOR> The error messages should have improved a bit with GHC 8.2[0], you might wanna check that out if you aren't already using it. For _stack_ that'll mean using the nightlies though (e.g. `resolver: nightly-2017-12-09`).

[0] [https://twitter.com/raichoo/status/825045995490795521](https://twitter.com/raichoo/status/825045995490795521)

</comment></comment><comment><USER20>
        x +- y = (x + x) - (y + y)

That's crazy.

I should learn Haskell (again).

<comment><USER21> what exactly is crazy about this?

<comment><USER22> The simplicity with which a new operator is defined.

<comment><USER23> I think this is a downside. It just makes reading new code that uses esoteric symbols defined elsewhere.

<comment><USER18> This[0] operator glossary reviews the most used operators.

[0]: [https://haskell-lang.org/tutorial/operators](https://haskell- lang.org/tutorial/operators)

</comment></comment></comment></comment></comment><comment><USER24> Nice guide for learning to read Haskell code! You have one minor type: "tree1123 :: IntTree

tree ="

<comment><USER18> thanks! fixed.

</comment></comment><comment><USER25> nice guide</comment>


The case for pair programming - <AUTHOR> https://tuple.app/pair-programming-guide/the-case-for-pair-programming <comment><USER2> I used to be a zealot. I had found the religion of XP, and I enforced pairing on teams I was hired to coach. Many people were happy to be exposed to it, but many weren't. Of those, some were better for the experience, some weren't. In either case, it was massively disrespectful of me to force it on people. Certain kinds of people are drawn to programming. Asking some of those people to pair all day every day is tantamount to asking them to switch careers. I for one don't have the emotional energy for it any more. Having said all that, I would encourage any skeptics to give it a try, in the right environment with the right teammates. It can really teach you a lot in a short period of time.

<comment><USER3> I feel the more general lesson here is that zealotry in our industry is almost always a bad thing. Whether it be in technology choices, development paradigms, project management techniques, training strategies, or even just how you deal with your staff and coworkers.

Whenever I come across a zealot in a professional setting, I'm fairly certain they're intentionally ignorant toward better ways of tackling certain problems (big red flag).

<comment><USER2> I agree, although I would qualify your last statement a bit to allow for (a) the zealot is usually well-intentioned, and (b) the zealot is usually not intentionally ignorant, but rather hasn't yet learned that context matters.

</comment></comment></comment><comment><USER4> I worked on a team pair programming for about 3 years. I really enjoyed it. Now that I've moved on to a different company and am working solo again, I _really_ miss pairing.

I feel that most of the problems my team has now would be easily solved by pairing. Things like shared standards (not just syntax but architectural approaches that are hard to automate), testing (you keep each other honest), and faster code review. Right now, if there's a bug in feature x, everyone goes to the feature x "guy" to have it fixed. If that person gets hit by a bus, feature x is hosed. People don't have a good idea what anyone else is working on (beyond the few that seem to do most of the code reviews). Swapping pairs every day or two easily solves these problems.

Things like on boarding new employees is just _so much faster_ that it's a no brainer to pair, especially when they're starting out. Junior developers learn _so much faster_ by working directly with a senior developer. Sure, it might slow the senior down (very little in my experience) but it makes the junior developer so much more productive in the long run.

Pairing is mentally exhausting at first and I can understand that it isn't for everyone. Most people hate it at first, especially if they have a bad setup. Most people I work with seem to think it means 2 people crowded around a single laptop. Setting up real pairing station with multiple BIG monitors and 2 keyboards and mice is crucial. After you get comfortable with it, the "always on" feeling goes away and it just becomes an enjoyable day working closely with your colleagues. If you really give it time, I feel it's the "right" way to develop software.

Switching a team to pairing might not be the right decision for everyone. Some people are just uncomfortable working with others. I'm not sure those people will be super strong members of most teams anyway, but they can certainly be successful in some organizations. If you build your team around pairing and select for it in your interview process, you can have really great results.

<comment><USER5> > Right now, if there's a bug in feature x, everyone goes to the feature x > "guy" to have it fixed. If that person gets hit by a bus, feature x is > hosed.

I think it's admirable to want to spread knowledge around as much as possible, I think having individual developers "own" specific applications or features is a net benefit. Sure if a developer leaves, they take their knowledge with him and someone else has to get up to speed, but that will necessarily happen anyway.

There is only so much room in your brain; the more features or projects you work on, the less you remember about any of them. Being able to go to the feature X "guy" most likely means the problem will be solved significantly faster. That person's caches are already primed, the pages are loaded from disk, and they can hit ground running. That is a much better case to optimize for than the off chance somebody gets hit by a bus. We also know that multitasking is bad for productivity so the less people have to focus on the better.

<comment><USER4> I think what's really nice with pairing is that you can have feature ownership and spread knowledge really easily.

The way I've done it in the past is that a feature will have an "anchor" or someone who owns it. They'll work on most of it and be in charge of interfacing with product on how it should work.

That person would switch pairs every day, working with a few people who then pick up some of that context. Being hit by a bus is the classic example, but a more realistic one is that the person goes on vacation. Now, instead of just being 1 person with deep context on that feature, there's potentially a few others that will know it well enough to solve the problem.

The people that are constantly switching will eventually own a feature and won't have to multitask all the time. Also, when you're pairing with someone, you get to share some of the focus with that other person, which I've found to make switching contexts a lot easier.

</comment></comment></comment><comment><USER6> I find pairing with anyone that is significantly outside the range of your competency level, to be extremely frustrating.

You can have a junior dev, and hand hold, but it also requires effort on the part of the junior dev / a desire to learn and grow. Without that, the exercise is futile.

IMO - pair programming is over-hyped. I often find that I produce better, more reliable code, with the more space and more time I am given. I agree that pair-programming can rock in certain circumstances - but you need developers that have a certain level of synergy, you can't force it.

<comment><USER7> > _You can have a junior dev, and hand hold, but it also requires effort on > the part of the junior dev / a desire to learn and grow. Without that, the > exercise is futile._

If someone's not interested in learning or growing, I don't see how pairing or not pairing makes a difference.

<comment><USER8> It is completely driven by senior developer. Many students find such pedagogy demotivating. They are not getting tasks they could solve autonomously and independently, every their step is watched as they are doing it. So, they don't even have chance to make mistake, realize mistake by themselves and then fix it. Imagine college classes done that way - everyone would rightfully complain.

Motivation and desire to learn are partly function of personality and partly function of environment.

<comment><USER7> > _Imagine college classes done that way - everyone would rightfully > complain._

The tutorial method is thousands of years old, actually. I suspect that if one-on-one education was economically feasible it would be the model chosen almost every time.

Having paired with people who don't know what "if" and "for" mean in a software context clear through to individuals who've been in software for longer than I've been _alive_ , I can only say that it works more often than not.

I often hear that pairing _would_ be terrible at this, pairing _must_ be dreadful for that, pairing _wouldn 't_ work for the other thing. What these have in common is that they are rejections based on mental simulation of events.

But ... I've actually paired. For years. It doesn't work for everyone but it _still works for most people_ , so long as they learn it from an experienced pair.

It is frustrating to see a thing work, over and over, then be told you must be wrong, it can't possibly work.

</comment></comment></comment></comment><comment><USER9> I started with XP way back in 99 after following the discussions on OTUG and then the white book came out.

I PP for 8 -> 9 years. Theres a bunch of things I learnt from that

It is really good for improving everyones skills. There is a fast convergence in good way to do things

The code quality is generally really good and people often develop good habits, everything gets discussed.

It doesn't work so well when people are across different projects, much better if they are all on the same project.

Teams reach a point where it doesn't actually matter if you pair or not, you tend to carry on making good code.

It can slow down experienced devs and they often don't get the same kind of "flow / mental zone" of coding they can get by themselves.

Developers need alone time to do their own coding experiments and to follow their own noses

It 100% has to be done right and people need to be open to the idea, I went into other companies who were trying to do it and it was failing massively. There was animosity and a lack of openness to trying it. People really didn't understand why they should do it, and felt coerced and threatened by it all. Untangling those messes seemed ... unproductive :)

It's exhausting.

These days I don't see the need for full time pairing, I see it more as a tool that has certain outcomes, and you use that tool when you notice certain kinds of problems / weaknesses. I would think that teams should "pair" at some point, and by that I mean watch each other code and have interactive discussion about code as it gets developed.

</comment><comment><USER10> Pairing with someone you get along with is a great experience. But with a lot of people I find it pretty miserable. I have paired with people who I just almost never agreed with. I am not saying they were bad but I just didn't like their style. There is also the risk of having one very dominant partner and the other one just watching passively (or having checked out already).

</comment><comment><USER11> The "How to pair with a junior developer" section is extremely considerate, and highlights some behaviours that I know I've subconsciously engaged in that may have negatively impacted a junior dev. Expanding this section would be great.

<comment><USER12> It actually makes a great reference. Today during a pair session a new developer happen to mention a technology that might solve X, Y and Z.

I think 5 or 10 years ago I would have shut them down - I was much more arrogant back then. Instead in the next few days this person is going to demo something they've built since they are pretty much our team's expert in this tech - since none of the others have used it. If everything checks out, this could very well be our next large architectural shift - and that's incredibly awesome contribution for someone new. Even if it means he'll be putting in a lot of extra work and time - in my eyes that's better than turning him into a robot that wants to check out exactly at 5pm.

</comment></comment><comment><USER13> I have to wonder how people make up for never getting into the zone.

<comment><USER14> I've been pair programming for about 6 weeks now, over Discord. The calling and screen sharing functionalities work so well that my partners and I can join and part quickly and easily. We can get deeply into what we're doing individually. But collaboratively, we can solve problems that neither of us can do alone.

I like this virtual setup for multi-user interaction a lot, and hope more tools, even ones specific to virtual programming environments, come for it soon. Tuple's making a remote sharing tool that looks interesting. What comes to mind for me is a shared 3D Wayland environment, like this [https://www.youtube.com/watch?v=_FjuPn7MXMs](https://www.youtube.com/watch?v=_FjuPn7MXMs) so, hopefully more people will start focusing on [https://github.com/way- cooler/way-cooler](https://github.com/way-cooler/way-cooler) and other Rust desktop/handheld application level development.

</comment></comment><comment><USER15> For contrast, here is an article I wrote that is largely against pair programming: [http://www.mattgreer.org/articles/pair-programming-is- not-a-...](http://www.mattgreer.org/articles/pair-programming-is-not-a- panacea/)

<comment><USER12> While I'm pro-pair programming I totally understand these issues. The way I normally go about it is put it out there that I like pair programming. And if other people in the team feels the same way, usually that just clicks.

I definitely think PP shouldn't be mandated at all. I think too that some of the issues you bring up are very important - especially about the notion that the soft spoken person will usually have their ideas rejected. A lot of developers act in very peculiar ways often because software development shops can be very toxic. Instead of addressing that toxicity, most places end up with a few head honchos. It really is bad for companies actually and can lead to many great budding engineers to leave or get out of the profession, sadly.

</comment></comment><comment><USER12> We got rid of the bad breath, smelly ass, coffee spill issues associated with pair programming. It's all remote now using VSCode Live Share and something like BlueJeans or Slack calls to facilitate the communication.

</comment><comment><USER16> [https://books.google.ca/books/about/Pair_Programming_Illumin...](https://books.google.ca/books/about/Pair_Programming_Illuminated.html?id=LRQhdlrKNE8C) << Pair Programming illuminated shows all the different kinds of combinations that are possible between programmers of different abilities and experience

</comment><comment><USER17> How well pairing works also depends on a person's personality. Introverts don't really do well in pairing situations, and especially when paired with someone totally opposite, the pairing essentially becomes a single person coding and the other person just observing and nodding their heads.

<comment><USER8> Plus beyond introversion, controlling and dominant people make everyone suffer during pairing. Also, shy people non-assertive people loose any possibility of autonomy or independent decision making (they might or might not find it uncomfortable). People who see everything in absolutes are hard to pair with and find it stressful. Extroverts who still like to think about problems silently or explore issues cant do that in pairing either.

The human social issues related to pairing are many more areas then just introversion extroversion.

</comment></comment><comment><USER18> Pair programming: when u need 2 devs to do 1 devs job

<comment><USER19> Please don't post shallow dismissals to HN. This is in the site guidelines: [https://news.ycombinator.com/newsguidelines.html](https://news.ycombinator.com/newsguidelines.html).

Fortunately you needn't look far for good examples of how to do substantive critique; there are some excellent ones in this thread.</comment></comment>


Lisp Flavoured Erlang 1.0 released after 8 years of development - <AUTHOR> https://github.com/rvirding/lfe <comment><USER2> Great news! I wanted to learn BEAM/OTP, but had tried Erlang briefly years ago, and then went back to Common Lisp. Now I can try to learn BEAM/OTP in a syntax that is more appealing to me than Elixir's Ruby-like syntax. I like Elixir, and it is very popular, but true runtime macros are available in LFE 1.0. In addition, Robert Virding was one of the co-creators of Erlang, so his devotion to bringing the best Lisp he could to the BEAM platform within its confines, comes with some authority. The Google Group Lisp Flavoured Erlang is a very responsive community and resource for getting started. Congratulations LFE on your v1.0! OT, but I also use Extempore - the music, graphics livecoding environment with a great language, xtlang that I believe was based upon S7 scheme and has an LLVM backend [1]. There are some s-expression to WebAssembly projects floating around too. All around good news for all the choices to work with up front no matter your preferences.

       [1]  http://extempore.moso.com.au/

<comment><USER3> Elixir is really not similar to Ruby and the comparison wears thin. This is my opinion after having used Elixir daily for the last 1.5 years and Ruby for 10 years before that.

Elixir really is a brilliant language and José et al have made the developer experience second to none with hex, mix, the language guide and docs. Compare how you bring up a repl: Elixir, type iex; LFE, cd into LFE dir, type ./bin/lfe. (EDIT: this is incorrect, see child) Trivial example and something easily fixed if it bothers you, but it's emblematic of the attention to detail that has gone into devx. I am deeply in love with Elixir. That Robert co- authored Erlang should not mean giving Elixir any less consideration IMO.

That said I sincerely wish to congratulate Robert on this 1.0, I look forward to using LFE in anger for something very soon now it is 1.0 (and it will be easy to slip in an LFE module into one of my OTP apps). Exciting times for the Erlang ecosystem.

<comment><USER4> > Compare how you bring up a repl: Elixir, type iex; LFE, cd into LFE dir, > type ./bin/lfe.

Is that a joke?

> If you have installed LFE, then you may start the REPL from any location:

         $ lfe

what you quoted is if you're running LFE straight from the git clone[0], and noted so.

[0] because you may not want a system-wide LFE and LFE is being a nice citizen in explicitly supporting that use case.

<comment><USER5> In actual fact, the LFE installation experience was a breath of fresh air:

        $ brew install erlang
        $ git clone ...lfe.git
        $ cd lfe; make && make install

        $ lfe

I miss make.

<comment><USER4> FWIW that can be further simplified to just `brew install lfe`: [https://lfe.gitbooks.io/quick- start/content/1.html#1-2-1-hom...](https://lfe.gitbooks.io/quick- start/content/1.html#1-2-1-homebrew)

<comment><USER6> Not only that, but an hour after your post, someone (burma-shave) had updated the LFE formula for v1.0 of LFE: * [https://github.com/Homebrew/homebrew/blob/f95c192d43d9a56bda...](https://github.com/Homebrew/homebrew/blob/f95c192d43d9a56bdaa67b8268c76310afacb96c/Library/Formula/lfe.rb)

</comment></comment></comment></comment></comment></comment><comment><AUTHOR> Robert Virding has just announced the release on twitter [https://twitter.com/rvirding/status/710259707819249664](https://twitter.com/rvirding/status/710259707819249664)

I feel that this LFE release further validates BEAM as a promising platform for future development of new programming languages. Also I look forward to reading SICP converted to LFE. Available chapters can be found here [https://www.gitbook.com/book/lfe/sicp](https://www.gitbook.com/book/lfe/sicp)

<comment><USER7> Given you mentioned SICP... SICP is cool for its math and its puzzle-like problems, but I found [http://scheme.com/tspl4/](http://scheme.com/tspl4/) a much better introduction to Scheme and more likely to help me solve problems with Scheme in the real world (i.e. a good reference book).

</comment></comment><comment><USER8> I've stumbled into an interesting related comment on twitter, didn't know:

 _" #Erlang based language ecosystem is more diverse than many know: #efene #reia #lfe #luaerl #erlog #elixir #mercury"_

[https://twitter.com/BillBarnhill/status/670601359016771584](https://twitter.com/BillBarnhill/status/670601359016771584)

 _edit:_ Wow, and many of them seem to actually be by the same rvirding who authored lfe:

[https://github.com/rvirding/luerl](https://github.com/rvirding/luerl)

[https://github.com/rvirding/erlog](https://github.com/rvirding/erlog)

<comment><USER9> Shame about luerl not supporting __metatable properly. That's half of why Lua is awesome.

Still a massive achievement, awesome stuff.

<comment><USER10> Main issue is that luerl does support metatables. That caveat was written ago and I can't remember what it was I didn't support then. But as I said now it works.

<comment><USER9> Kudos! That's really awesome then.

I've got a lot of love for Lua(works great in embedded spaces, we use to do game logic in ~400kb block on a PSP with ~8mb of RAM).

Metatables are such an great way of exposing composability without putting a lot of restrictions on how the language works.

</comment></comment></comment></comment><comment><USER10> I do want to point out that LFE has been release ready and of production quality for a long time but I tend to suffer from a "Jag ska bara"* syndrome which has delayed things. :-)

* I am just going to ...

<comment><USER11> Thank you so much for this wonderful stuff!

</comment></comment><comment><USER12> Robert Virding gave a short talk on LFE at ClojuTRE last year: [https://www.youtube.com/watch?v=BvCBTpnlqs8](https://www.youtube.com/watch?v=BvCBTpnlqs8)

</comment><comment><USER13> Virding's YouTube presentation at a Clojure conference about this new lisp says this in the caption:

>LFE (Lisp Flavoured Erlang) has been designed to run efficiently on the Erlang VM and at the same time be a "real lisp" providing Lisp's good bits.

It also knocks Clojure a bit. What do you all think are the "good bits" of lisp that Clojure lacks?

<comment><USER14> FWIW, reading this sentence w/o any extra context, it doesn't seem to imply anything bad about clojure.

<comment><USER13> The bit about Clojure was additional information in the source that I did not quote.

</comment></comment></comment><comment><USER15> This looks really interesting. I installed it easily through Brew. REPL seems to work fast.

Now if my Clojure flawored Lisp starter level knowledge could be somehow transformed into Erlang flawor...

I wrote this:

        > (map (lists:seq 1 10) (lambda (a) (io:format a)))

and this happened:

        #M((1 2 3 4 5 6 7 8 9 10) #Fun<lfe_eval.12.88887576>)

So, I'm not quite there yet. Hopefully somebody can make a Clojure to LFE comparison.

And using Elixir based things like Phoenix springs to mind...

<comment><USER16> Map is a constructor in this case. You'll want lists:map/2 (fn comes first). I don't know LFE much so there may be sugar of sorts for this, perhaps a comprehension syntax.

<comment><USER10> Yes, there are list comprehensions but they return the list of values:

(lc ((<\- x (lists:seq 1 10))) (lfe_io:format "~p" x))

<comment><USER15> Thank you both. I didn't realize how Erlang flawored this really is. This did the trick:

        > (lists:map (lambda (a) (io:format (integer_to_list a))) (lists:seq 1 10))

Though all those OKs look kind of superfluous. I must read Erlang tutorial or two before I proceed.

<comment><USER17> io:format is a side-effecting function. It prints to the terminal. The atom ok is the return value.

If you want to create a list of strings, this works:

        > (lists:map (lambda (a) (lists:flatten (io_lib:format "~B" (list a)))) (lists:seq 1 10)).
        ("1" "2" "3" "4" "5" "6" "7" "8" "9" "10")

</comment></comment></comment></comment></comment><comment><USER18> > A proper Lisp-2, based on the features and limitations of the Erlang VM

What are limitations?

<comment><USER19> One obvious example is that AFAIK the VM doesn't support functions with a variable number of arguments (foo/1 and foo/2 are two separate functions). This means that you can't have CL-style &rest or &key arguments.

<comment><USER20> This is a feature to me more like a limitation. I do not like optional arguments &rest style. In Erlang you need to have explicit number of arguments and need to explicitly implement them. I really like that. Keep in mind that default values are trivial to implement when the smaller arity function calls the higher arity one with added values. Or you can call in yourself to the higher arity function and specify the parameters yourself. In my opinion this is elegant and safe way of dealing with the problem.

<comment><USER21> _In Erlang you need to have explicit number of arguments and need to explicitly implement them._

Or, you know, just use lists as parameters. That's the standard Erlang pattern for unknown parameters lengths (e.g. io:format("debug ~s because ~p~n", [SomeString, SomeType]))

<comment><USER22> Firstly, this still requires a mechanism which underlies the [ ... ] notation for evaluating a sequence of any number of expressions and constructing a list.

In Lisp dialects, that is done by a variadic function:

      (list 1 2 3 4 ...)

Of course, if we don't need to indirect on this function, we could implement it as a macro (supposing further that we have variadic macros for compile time, but not variadic functions for run time).

The macro would turn (list 1 2 3) into the non-variadic calls (cons 1 (cons 2 (cons 3 nil))).

I imagine that's a conceptual facsimile of what Erlang's list constructor notation is doing.

Erlang has variadic features in its read syntax; without a doubt its BNF is chock full of "zero or more of ..." grammar productions. The function defining mechanism lets you define a function which has any number of arguments; just that number has to be fixed for that function. So the mechanism itself enjoys variadic application. Here it is asked to define a three-arg function, here a ten-arg, ...

We can simulate some aspects of variadic application with syntactic sugar, but not all. A Lisp function call which specifies five arguments can call a function which requires exactly five arguments, or a function which requires three arguments, followed by variadic ones.

For instance, if we have a callback registration interface that passes five arguments, the client can supply a fixed arity function, or a variadic one.

I suppose that if everything is static, that can still be worked out. The compiler sees that a variadic function with only two required args is passed as a callback that must be 5-ary, so it inserts a conversion shim: an anonymous function which takes exactly 5 parameters and applies them to the 3+rest function.

<comment><USER10> LFE macros can have variable number of arguments. The compiler does very little in helping with this as there are in principle no inter-module dependencies. This is a requirement of the dynamic code handling which allows you to reload any module at any time without any requirements on the contents. All checking is done at run-time. This is a basic property of the Erlang system and to make something which is fully compatible you have to follow this.

One way to have made LFE fully variadic in its functions would have been to have made each function only take one argument which is a list of the arguments in the call. This would have been easy to do but made it very difficult to interface LFE with the rest of the Erlang system in a clean way.

</comment></comment></comment></comment></comment></comment><comment><USER23> The users manual has a stub section for macros; does anybody know how LFE macros work? It says "lisp style" but that allows at least 4 options (syntax pattern-matching versus classic defmacro, and capturing versus non-capturing).

<comment><USER24> There's some more in-depth documentation in the repo in doc/user_guide.txt, at around line 520-ish.

It has Common Lisp style defmacro (augmented with pattern matching), and Scheme-inspired defsyntax. The documentation warns that both are unhygienic, and `grep -ri gensym` didn't find anything in the repo.

<comment><USER23> So I guess you just have to be super careful with variable and function names? That's the dark-ages for lisp, but still usable.

</comment></comment></comment><comment><USER25> My exposure to the Erlang world is limited to having read the first few chapters of Programming Elixir. Is interop trivial? Can you easily use Erlang, Elixir, and LFE in the same project?

<comment><USER26> Yes, compiling a module where the source was written in another language is no different from calling a module written in the same one. In Elixir any time you call a module that starts with a `:` it has most likely been written in Erlang.

<comment><USER3> Technically all modules begin with : as module references are atoms. iex just hides it from for Modules made with defmodule (they have :Elixir prepended to them) /trivia

</comment></comment></comment><comment><USER27> The docs are sadly very incomplete still. :-(

How do I go about sponsoring a technical writer to complete them?

</comment><comment><USER5> I'd love to see a comparison with Clojure, anyone know of such a thing yet?

<comment><USER6> It's a work in progress, but this might be useful:

* [http://lfex.github.io/hyperpolyglot/](http://lfex.github.io/hyperpolyglot/)

<comment><USER5> Great - thanks.

</comment></comment></comment><comment><USER28> Slightly off topic: does anyone have an update on BEAM JIT?

</comment><comment><USER29> Just waiting for the day when someone launches a js version then the whole world is gonna be coding on erlang vm I think.

<comment><USER3> I doubt it. IMO Erlang is fundamentally a different model of programming than JS and what about mutability and things such as pattern matching? It quickly becomes apparent that it would not be much like JS if it was to take advantage of all of Erlang's best bits.

<comment><USER30> Exactly, Erlang is a DSL for distributed applications. There is not much point to use it for anything else.

<comment><USER31> Erlang and related languages are applicable for most long-running applications.

The amount of people who actually use true distributed Erlang is probably small, because you get many of the benefits either way.

</comment></comment></comment></comment><comment><USER32> Could you believe that 2016 is the year of the beginning of the LISP renaissance.

Im going to buy some spare paren keys, they might become scarce in the immediate future.

<comment><USER33> It started in 2007 with the release of Clojure and there are still plenty of paren keys around.

<comment><USER34> The Lisp renaissance started in December 1999 with SBCL being forked from CMUCL.

<comment><USER35> On the other hand, 1999 was the downfall of LISP in the statistical community because that's when Luke Tierney decided to stop working on LISP-STAT, a LISP dialect with extensions for statistics that was semi-popular before the advent of R. While there have been statistical systems based on LISP since (such as Incanter for Clojure and a port of many of the extensions of LISP-STAT to Common Lisp) none have managed to make a dent against R, unfortunately.

<comment><USER34> That was the consequence of users switching to S/R years before.

[https://www.jstatsoft.org/article/view/v013i07/v13i07.pdf](https://www.jstatsoft.org/article/view/v013i07/v13i07.pdf)

Users of maths software usually don't want to use Lisp syntax and are not ready to work in Lisp.

XLisp-Stat had also the problem that it used its own Lisp implementation, based on XLisp (upto Xlisp 2), which itself wasn't going anywhere. David Betz, the original author of Xlisp, rewrote Xlisp as a form of Scheme (Xlisp 3.0) and it died eventually. Xlisp-Plus, another Xlisp version, was mostly abandoned also in that timeframe - though there are updated versions available now.

Other math software, which had been ported to Common Lisp, is still maintained - like Maxima. The maintainers can concentrate on the application and the code is much easier portable to new systems because of a choice of implementations.

Had XLisp-Stat been fully ported to Common Lisp (actually a rough port of the Xlisp-Stat core to Common Lisp was done many years ago) and maintained there - at least the code would still be easier usable.

<comment><USER6> Having used early versions of Mathematica in university, I'm actually a huge fan of Maxima (a fork of Macsyma, the latter having been the principle inspiration behind Mathematica). I have it installed on several systems and use it now for all the things I used to use Mathematica. In fact, the CL source code for rational numbers in Maxima formed the basis of similar work in LFE (the horatio project).

I was very sad to find out that Xlisp-Stat had not been ported and maintained in CL :-/ ... perhaps a good project for a motivated, if fringe, *SoC project :-)

<comment><USER34> This is a Common Lisp version of the Xlisp-Stat core from 1996:

[http://homepage.stat.uiowa.edu/~luke/xls/xlispstat/other/CL/](http://homepage.stat.uiowa.edu/~luke/xls/xlispstat/other/CL/)</comment></comment></comment></comment></comment></comment></comment>


Ask HN: What is a good tick data source? - <AUTHOR>

I'm working on a small side project where I require Level I tick data for NYSE or Nasdaq's tapes respectively. Does anyone on HN know a (preferably free) source of this historical market data? <comment><USER2> Tick data for free is rare...you can get it from the exchanges but you may have to pay...if your side project could be of interest to a fund you may be able to convince them to give it to you in return for information re your results

<comment><AUTHOR> Interesting idea, I initially had that angle with Nanex, but I haven't been able to contact them yet.

<comment><USER3> I'd be wary of Nanex and their data quality in general: <https://news.ycombinator.com/item?id=5146571>

Most people offering market data risk running afoul of the contractual agreements signed with the various exchanges.

</comment></comment></comment><comment><USER3> Did you try <http://tradingphysics.com/> ?

<comment><AUTHOR> I haven't, thanks for the info, I'll check 'em out later today.</comment></comment>


Grocery buying market requires remake - <AUTHOR> https://docs.google.com/forms/d/1TkJg_MNbY63Mh9xJH55l-nOUs0X49TqU21m1HWQjXr0/viewform?c=0&w=1

<comment><AUTHOR> Follow the link to participate in the survey. Will be very helpful.</comment>


Vip – Vi-Style Editor in PicoLisp - <AUTHOR> http://picolisp.com/wiki/?vip <comment><USER2> I absolutely love the concepts behind Picolisp, but really wish Alexander or the community would write a beginners tutorial. I can mostly understand some of the reference material, but it is just too strange coming from a traditional imperative background.

<comment><USER3> ? (de a a a)

-> a

? (a b c d)

-> (b c d)

<comment><USER2> I wouldn't know, but the folks on the picolisp mailing list on the website are very responsive and knowledgeable on design decisions. They are a small, but active community.</comment></comment></comment>


The Algorithmic City - How can we scale cities for the future? - <AUTHOR> http://www.huffingtonpost.com/rand-hindi/sustainable-cities_b_3141830.html

<comment><USER2> So interesting, thx Rand !</comment>


Ask HN: Did you get a VR headset for Christmas? - <AUTHOR> <comment><USER2> i bought myself an asus win MR headset cheap to play about with, given that i only paid £130 its a pretty cool piece of kit but ive only really used it to play a few games like superhot VR and space pirate trainer.

Pros: Easy setup, just plug 2 cables in and done. Light

Cons: not the greatest padding not as adjustable as the likes of PSVR/Oculus/Vive controllers eat batteries rapidly

in short its a nice cheapo VR system, at the moment there just isnt the content to justify spending upwards of £300 on a setup but i could justify closer to 100 just to play about with it and keep it in case something else worthwhile comes out

</comment><comment><AUTHOR> If you did get one (or already had one): Which one, and how do you like it? What do you use it for mostly?

</comment><comment><USER3> I did not</comment>


Silicon Valley Has an Arrogance Problem - <AUTHOR> http://online.wsj.com/news/articles/SB10001424052702303661404579175712015473766 <comment><USER2> Wall Street has an arrogance problem.

Mainstream journalism has an arrogance problem.

</comment><comment><USER3> As much as I normally don't grant points to the _Wall Street Journal_ , I'm granting this one.

Proposals for techno-libertarian entrepreneurial utopias on the sea are just the tip of the iceberg. After those, we have to address the property regime that makes the Bay Area increasingly uninhabitable to run-of-the-line engineers, the exclusion and marginalization of the everyday working class people who make the whole area run (see: the BART strike), and the entire underlying sentiment of "Software engineering is the master race".

When we have started thinking of ourselves as the indispensable heart of society and everyone else as mere utilities for use to exploit, yes, we have become extremely arrogant and need to be reigned in.</comment>


Open Source Design Manifesto - <AUTHOR> http://opensourcedesign.is/ <comment><USER2> aside from the "manifesto" angle, this could be a help-wanted ad seeking an intern web-designer.

-bowerbird</comment>


Hey Google, sorry you lost your ethics council, so we made one for you - <AUTHOR> https://www.technologyreview.com/s/613281/google-cancels-ateac-ai-ethics-council-what-next/ <comment><USER2> Ironically given the ethics related topic, the article is behind a creeper wall.

"Give us your email and you can read."</comment>


Understanding Moscow: The Mysteries of the Russian Mindset - <AUTHOR> http://www.spiegel.de/international/world/understanding-moscow-the-mysteries-of-the-russian-mindset-a-1162072.html <comment><USER2> > Putin is making Russia a dissident from the world order ...

I don't think he is making it, rather there is growing trend against this world order in most countries. And righfully so as this world order tends to care only about wealthy people and nations ...

</comment><comment><USER3> I'm not sure whether this is a good description of Russian culture in general nor how to objectively evaluate such a thing, but as an American I found it very entertaining to hear a German author make the attempt at comparative cultural evaluation.

It rather reminded me of conversations with my Dutch or German friends, with whom I agreed that their cultures were more cooperative/communalistic in character. These friends would often say things like: "In Germany, a grandmother would swat you with a rolled up newspaper for taking up two seats on the bus that way." or "Americans insist on having too many choices, one flavor of yogurt should be enough for anyone!", and so on.

</comment><comment><USER4> Can't think of an explanation more true and concise that is not a cultural studies PhD work than this article

</comment><comment><USER5> I wonder how much of the citizens' indifference to and mistrust of the government and politics is a product of living for decades in a communist authoritarian state, as opposed to a fundamental nature of the people there. Seems like a classic case of fundamental attribution error.

<comment><USER6> >I wonder how much of the citizens' indifference to and mistrust of the government and politics is a product of living for decades in a communist authoritarian state, as opposed to a fundamental nature of the people there.

Communism was preceded by many centuries of feudalistic, authoritarian monarchy. The communists inherited a people who already had a passive peasant mindset, and they just exploited it, as Putin is doing now.</comment></comment>


The Verdict on Systemd Is In - <AUTHOR> https://fossforce.com/2020/02/the-verdict-on-systemd-is-in/ <comment><USER2> > But if cautious, ultra-democratic Debian can opt to retain systemd, then it > seems here to stay for the foreseeable future.

Yes, I agree. That's why I'm shifting to BSD.

</comment><comment><USER3> It has been five and a bit years since Wikipedia stopped falsely claiming that to be a block diagram of systemd, and it's _still_ being circulated as such.

* [https://en.wikipedia.org/wiki/Special:Diff/631112520](https://en.wikipedia.org/wiki/Special:Diff/631112520)</comment>


How Mobile Commerce Will Yield the Next $100B Startup - <AUTHOR> http://mattermark.com/phil-carter-patricia-nakache-of-trinity-ventures-show-how-mobile-commerce-will-yield-the-next-100b-startup/

<comment><USER2> That's a lot of buzzwords with not a lot of value. If you're planning on existing in this space, you already know all this, and you're looking at the white spaces outside the diagram.

</comment><comment><USER3> the question this begs is more like.. what is the category which is not yet claimed in this field. It looks crowded in this frame, and many of these companies are reaching the $10-$20b stage (airbnb, uber, etc).

So the natural question is what is unexplored.

<comment><USER4> Not trying to be insulting, just a friendly tip :-)

It raises the question, begging the question is something different.

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

<comment><USER5> The funny thing is that "begging the question" is itself a mistranslation, so I really can't fault people for thinking it means what it literally means. (Throw in the fact that literally now literally means 'not literally'...)

Language is a mess.</comment></comment></comment>


Exploring dark energy with robots - <AUTHOR> http://www.symmetrymagazine.org/article/june-2015/exploring-dark-energy-with-robots

<comment><USER2> Dark energy is such a stupid term. You can tell it's a term designed to court funding, and garner intrigue.

If they used the term "unknown energy" instead, review boards would look at the grant proposal and just shake their heads. Maybe "unexplained/anticipated energy" would stand a better chance as a term. For added excitement, the three letter acronym UAE could be used to foster an impression of technical expertise and mystery.

<comment><USER3> Huh, weird. It's almost as if scientists and researchers had to consider how to best communicate with people.

<comment><USER4> Sadly these scientists of DARKNESS do not communicate at all with people (and stay stupid). [http://ow.ly/MrQgy#hossenfelder](http://ow.ly/MrQgy#hossenfelder)

<comment><USER3> That article sure does focus on what a bad guy Einstein was, instead of on actual research and facts.

<comment><USER4> You are right of course. And I have to accept why scientists refuse reading my blog post. It's indeed not research in its own right - it simply tells what 1+1 gives.

<comment><USER3> > _I have to accept why scientists refuse reading my blog post_

Or you could show some adaptability.

</comment></comment></comment></comment></comment></comment><comment><USER4> Dark energy is not only a stupid term, it's a stupid topic. -- Even I can write spectacular papers on "dark energy". My main statement: -- There are two opposing assumptions concerning measured increase of distances between galaxies (redshift): a) Redshift is about velocity of masses IN space (about force, momentum, energy) or b) it is about scaling OF space itself (a factor like time is, not about force, momentum, energy). For nearly a century physicists know the latter is true, but calculate and argue with the former assumption (called 'dark energy' later on). -- Not because they are idiots but because they think people are and will not notice Einstein was wrong. -- More: [http://ow.ly/MrQgy](http://ow.ly/MrQgy) [http://ow.ly/LGgJo](http://ow.ly/LGgJo)</comment>


How to power Laptop when power fails regularly - <AUTHOR> Hey Hackers , I live in a place where power fails regularly for few hours almost daily . Got this work from home privilege . How to keep my laptop powered painlessly and coolly for say about 12 hours. For smaller devices like smartphones and tablets there is USB powerbank , which are really handy and will fit in your shirt pocket. What is the equivalent for a laptop ( 65W,19.5V,3.34A)? The standard solution is a diesel generator or a battery-invertor . Is there any cool solution , since I don't need the generator in other ways . I thought of buying 2 more Laptop battery for my model and keep them under charge always . <comment><USER2> You should just get a UPS. The APC-Back-UPS-350 runs my 4bay nas and my iMac for about 650 sec. Thats fine for me. If only I use my Macbook and the nas I'll get around 5500 sec. This combined with the time to drain the laptop battery is good for me.</comment>


Apache Wicket's encrypted URLs don't protect from CSRF - <AUTHOR> https://www.smrrd.de/apache-wickets-encrypted-urls-dont-protect-from-csrf.html

<comment><USER2> It's somewhat bizarre to obfuscate the URL thinking it will stop CSRF, if there's no anti-forgery token embedded within.

As Fabian says, just do the CSRF with the encrypted URL if it's not stateful. When Apache Wicket does add state, apparently it's just a small incrementing integer. Like an 8 bit anti-forgery token.

But all of this seems like so much over-engineering when one line of Javascript to add a non-standard request header, and one line on the server to fail if it's not present -- that's all you need?!

What I'm wondering, if you add an X- header with no actual token, do we agree that's enough these days? I remember an old Flash version which allowed adding X-headers outside the SOP, is that the only reason it's not considered fully safe? I think if you're running outdated Flash your machine is completely owned anyway and Anti-CSRF won't make a difference.

[1] - [http://security.stackexchange.com/questions/23371/csrf- prote...](http://security.stackexchange.com/questions/23371/csrf-protection- with-custom-headers-and-without-validating-token)

<comment><USER3> You'll notice a lot of people just have X-CSRF.* header (Stripe for example if you want to check one out). In my opinion you might as well just go the full 9 and actually implement an anti-CSRF solution instead of a quick hack.

x-Requested-By works but your webapp can be built in a way that things like insecure redirects fool you app.

The best solution is just to use tokens.

</comment></comment><comment><USER4> Wicket doesn't actually say it prevents CSRF, it says:

 _Sometimes URLs are a double–edged sword for our site because they can expose too many details about the internal structure of our web application and malicious users could exploit them to perform a cross-site request forgery._

To me, all this means is that it hides the url parameters so that the users can't find as much about the workings of your app. To simply assume that this is a means for protecting your app entirely from CSRF would be stupid.

</comment><comment><USER4> 404 from the main site so here is the Google cached version: [http://webcache.googleusercontent.com/search?q=cache:https%3...](http://webcache.googleusercontent.com/search?q=cache:https%3A//www.smrrd.de/apache- wickets-encrypted-urls-dont-protect-from-csrf.html)

</comment><comment><USER5> 404 Not Found

<comment><USER6> Is this a bot account? I am also getting a 404

<comment><USER7> Heh, no I think it's coincidence. Check the accounts' comments.</comment></comment></comment>


Ask HN: What age you started to program? - <AUTHOR> <comment><USER2> I think my very first forays into programming were around 7th or 8th grade, so about 10 or 11 years old. But it didn't really "hook" me then, maybe in part because I didn't have a proper computer... just a "Bally Arcade" game console with a BASIC cartridge you could plug in. But without a keyboard, entering code was really tedious and painful.

When I really think of myself as "getting into programming big time" was my first year of college. I would have been 18 then. I took a couple of programming classes as electives, and "the bug bit" as they say, and I bought the parts to build a PC (386DX40 FTW!) and downloaded a shareware C compiler from a BBS, bought Herbert Schildt's book _Teach Yourself C_ and just dove in... never looked back. :-)

</comment><comment><USER3> I took "intro to C++" as a freshman at my university. So 18 year's old. I started working with PHP at by buddy's start up shortly thereafter. I took a couple more classes. I minored in CS. I coded for fun and some small client projects while I worked in other industries for a decade. I then became a real, professional developer at around age 28.

</comment><comment><USER4> 9 with BASIC. Then x86 Assembly and C around 14. Pascal and VB around 15 (mainly for disassembly and virus learning). Delphi (Pascal) around 16.

I'm 32.

</comment><comment><USER5> maybe around 10. I was sent to a programming club learning logo, then another club to learn qbasic. I hated programming very much.

A few years later, I got interested in game and graphics programming, I started to like it since then.

</comment><comment><USER6> When I was around 8 my parents had ne take a class in logo.

</comment><comment><USER7> Basic on the commodore 64 at 10 years old.</comment>


Modular, fully libre computer card - <AUTHOR> https://www.crowdsupply.com/eoma68/micro-desktop <comment><AUTHOR> The cool thing this does is specify the interface between the SoC and the case, whether that case is a phone, tablet, robot, or laptop.

I'd really like to see this project get off the ground.</comment>


GitHub banned us without notice – Is Microsoft the risk we didn't consider? - <AUTHOR> https://medium.com/swlh/github-banned-us-without-notice-is-microsoft-the-risk-we-didnt-consider-a153f11cb1b1 <comment><USER2> Microsoft's acquisition of Github hasn't closed yet, so the company is still operating independently. There is no reason to think that this has anything to do with Microsoft.

To be honest, it seems like a fairly simple mistake that was cleaned up within 48 hours. Certainly a pain in the ass, but these things happen.

<comment><USER3> The Microsoft-fear in this article isn't justified.

However, the author does point out several good practices:

* Don't host your code only in one place

* Don't host your services only in one provider

* Don't host your backups only in one provider

I suppose you could argue the second one, but the other two are important to follow.

<comment> m-p-3 Yeah, treat code as any kind of data.

If it's worth a lot of time and cannot be replaced easily, back it up.

</comment></comment></comment><comment><USER4> Their Github account at [https://github.com/prowriting](https://github.com/prowriting) looks boringly normal. I wonder what could have caused Github's systems to flag it and a customer service rep to decide it was not legitimate.

<comment><USER5> There doesn't seem to be much going on there? Over 13 repos, there are like 5 issues, all open, with one response that seems to be from some other user who just randomly wandered in? There are a few commits and a couple of branches, but no releases. Also a couple really ancient forks. This looks like a random person's GitHub page, not a software company's.

They also don't have any links to their GitHub pages on their site. This isn't how organizations normally use GitHub. One suspects they're just using it as a CDN without engaging with any of the coding or social features. Perhaps GitHub has some sort of trigger when particular resources get requested over and over without any referer? Why not just use GitHub normally? Failing that, why not just use a CDN?

<comment><USER6> CDNs cost money. The whole point of most businesses lately seems to be externalizing costs while providing the least amount of service that they can get paid gobs of money for. I understand that's a sound business model in a race to the bottom, but eventually you hit the bottom and the whole market losses.

<comment><USER5> They don't cost enough money to justify this whole embarrassing episode. Probably they're just a little bit harder to configure than it was to just dump everything on GitHub.</comment></comment></comment></comment>


How to Become a Hacker(not a cracker) - <AUTHOR> http://www.catb.org/esr/faqs/hacker-howto.html <comment><AUTHOR> On the journey to becoming an open-source software hacker, UNIX culture and learning programming.</comment>


Elements of Ruby Style - <AUTHOR> http://www.pathf.com/blogs/2008/10/elements-of-ruby-style/

<comment><USER2> This list is crap. He advocates the ridiculous

        x = if boolean then 3 else 5 end

in place of

        x = boolean ? 3 : 5

Then we have

      return if x = null

which _assigns_ the value of "null" to x (if null exists). Maybe he meant

      return if x == nil

If so, this is better rendered as

      return if x.nil?

Finally,

      all_users.select(&:is_active).map(&:name).sort

isn't standard Ruby; it will (currently) only work in Rails.

<comment><USER3> _all_users.select( &:is_active).map(&:name).sort_

 _isn't standard Ruby; it will (currently) only work in Rails._

It's standard in 1.9, and making it work in 1.8 is all of 3 lines:

        class Symbol
          def to_proc() proc {|obj, *args| obj.__send__(self, *args) } end
        end

Or if you've got facets:

        require 'facets/symbol/to_proc'

<comment><USER2> _It's standard in 1.9_

That's why I said "(currently)". From the official Ruby homepage: _The current stable version is 1.8.7._

 _making it work in 1.8 is all of 3 lines_

I agree, but this still makes it not standard Ruby. The article should have mentioned this.

</comment></comment></comment><comment><USER4> It is so sad that this is still what people worry about for code style. Anything here could be done in an automatic code formatter written in a weekend.

Why not an article on, say, Ruby API design? Use blocks, overload these (but not these) operators, DSLs, etc?

You know, elements of style that matter?

</comment><comment><USER5> Advocates readability in one instance, then says to use fewer spaces for indentation? The only reason to use indention less than 4 spaces (some would say even 4 is too few) is so you can cram more nested statements in, and if you're running out of room nesting such that a smaller indentation would help, your problem is not related to indentation.

</comment><comment><USER6> Why break lines at a fixed length yourself instead of letting your editor's wordwrap handle it?

<comment><USER7> The wrapped line (2nd line, if you will) is not indented. I find a word- wrapped line of code more difficult to read than a manually broken and indented line of code.</comment></comment>


Programming from A to Z - <AUTHOR> http://shiffman.net/a2z/ <comment><AUTHOR> h/t this r/programming thread: [https://www.reddit.com/r/programming/comments/5hlx4e/this_gu...](https://www.reddit.com/r/programming/comments/5hlx4e/this_guy_taught_me_better_than_my_professor/)

I completely agree with the idea of teaching regular expressions early on. I'm teaching a course in the winter and plan to make regex my first topic. Can't say it much better than Cory Doctorow did:

[https://www.theguardian.com/technology/2012/dec/04/ict- teach...](https://www.theguardian.com/technology/2012/dec/04/ict-teach-kids- regular-expressions)

> I think that technical people underestimate how useful regexps are for > "normal" people, whether a receptionist labouriously copy-pasting all the > surnames from a word-processor document into a spreadsheet, a school > administrator trying to import an old set of school records into a new > system, or a mechanic hunting through a parts list for specific numbers.

> The reason technical people forget this is that once you know regexps, they > become second nature. Any search that involves more than a few criteria is > almost certainly easier to put into a regexp, even if your recollection of > the specifics is fuzzy enough that you need to quickly look up some syntax > online.

> Knowing regexp can mean the difference between solving a problem in three > steps and solving it in 3,000 steps. When you're a nerd, you forget that the > problems you solve with a couple keystrokes can take other people days of > tedious, error-prone work to slog through.

</comment><comment><USER2> Wow, nice find. Let's all appreciate how fucking dope Daniel Shiffman's videos are:

[https://www.youtube.com/user/shiffman/videos](https://www.youtube.com/user/shiffman/videos)

</comment><comment><USER3> Looks like a quality channel for learning new programming skills. Can anyone recommend any other youtube channels for this sort of stuff? I've heard funfunfunction is also very good.</comment>


Breaking Through the Normalization Barrier: A Self-Interpreter for F-omega - <AUTHOR> http://compilers.cs.ucla.edu/popl16/ <comment><AUTHOR> Abstract

According to conventional wisdom, a self-interpreter for a strongly normalizing λ-calculus is impossible. We call this the normalization barrier. The normalization barrier stems from a theorem in computability theory that says that a total universal function for the total computable functions is impossible. In this paper we break through the normalization barrier and define a self-interpreter for System F_ω, a strongly normalizing λ-calculus. After a careful analysis of the classical theorem, we show that static type checking in F_ω can exclude the proof's diagonalization gadget, leaving open the possibility for a self-interpreter. Along with the self-interpreter, we program four other operations in F_ω, including a continuation-passing style transformation. Our operations rely on a new approach to program representation that may be useful in theorem provers and compilers.</comment>


Apache, Nginx, Lighttpd, Monkey, and BarracudaDrive Speed Test - <AUTHOR> http://barracudadrive.com/blog/2013/03/Apache-Nginx-Lighttpd-Monkey-and-BarracudaDrive-Speed-Test

<comment><USER2> Not opensource, so basically I don't think anybody is going to use it.</comment>


CBP says it's 'unrealistic' for Americans to avoid license plate surveillance - <AUTHOR> https://techcrunch.com/2020/07/10/cbp-license-plate-surveillance/ <comment><USER2> We should abolish CBP as well as ice, make license plate monitoring illegal (if possible). Ang restrict the border cops to just a few miles of the border.</comment>


The Ice Balloon – A doomed journey in the Arctic (2010) - <AUTHOR> http://www.newyorker.com/magazine/2010/04/19/the-ice-balloon <comment><USER2> There's no real explanation of why they landed and abandoned the balloon, which seemed to be in good working order at the time and was moving them well, if not exactly in the direction of the pole.

The article says simply, "Early on the morning of the fourteenth, the fog thickened and the car began to hit the ice again. Then the balloon rose 'to a great height,' Andrée wrote. They released some of the gas to lower themselves, then, a little after eight, apparently resigned to disappointment, they landed and 'jumped out of the balloon . . . worn out and famished.' They had been aloft for sixty-five hours and thirty-three minutes, had travelled five hundred and seventeen miles, and were about three hundred miles north of where they had started; that is, about three hundred miles south of the Pole."

So the balloon was still fully functional, and the rest of the account makes clear they had plenty of provisions left (and after all had only been in the air for a few days) so why did they embark on their perilous and ultimately deadly journey across the ice?

<comment><USER3> I'm guessing that if the balloon was often scraping ground, and they let gas out, it would be even worse. But the article could have clarified this, and at least spent a little more time on this pivotal moment of the narrative.

<comment><USER4> Yes, Balloons control their height by dropping ballast and/or releasing gas. When they eventually run out of ballast, they can no longer control the balloon.

</comment></comment></comment><comment><USER5> Damn interesting made a great podcast on this. You can listen to it here: [https://soundcloud.com/damn-interesting/andree-and-the- aeron...](https://soundcloud.com/damn-interesting/andree-and-the-aeronauts)</comment>