You may finally use JSHint for evil - <AUTHOR> http://mikepennisi.com/blog/2020/jshint-watching-the-ship-sink/ <comment><USER2> The project has been "rewritten from scratch" [1] in order to sidestep the legal requirement of preserving the original license (from JSLint, which it was forked from), against both the original authors' wishes [2].

A whole lot of post-rationalization of how the unconventional license caused the project to slow down: [http://mikepennisi.com/blog/2020/jshint-watching- the-ship-si...](http://mikepennisi.com/blog/2020/jshint-watching-the-ship- sink/). Certainly not due to ESLint's extensible design, customization options, better error messages, ES6 and JSX support and adoption by multiple mainstream libraries.

Legal implications aside, it's still sad to see that 'do no evil' is so hard to agree with.

[1] [https://jshint.com/relicensing-2020/index.html](https://jshint.com/relicensing-2020/index.html)

[2] [https://github.com/jshint/jshint/issues/1234#issuecomment-23...](https://github.com/jshint/jshint/issues/1234#issuecomment-23187063)

<comment><USER3> The part that explains why this clause (originally written by Douglas Crawford in the JSON license) is a problem for free software:

> If you're not versed in legal matters, that probably seems like an odd > restriction. By rejecting JSHint, are people admitting that they want to do > evil? And is that clause actually enforceable, anyway?

> The answer to the second question is "no," and that helps answer the first > question. Legally-conscious objectors aren't betraying their own dastardly > motivations; they're refusing to enter into an ambiguous contract. Put > differently: they're not saying, "I'm an evildoer," they're saying, "I don't > understand what you want." This consideration disqualified JSHint from > inclusion in all sorts of contexts.

<comment><USER2> As an admirer of the WTFPL it's hard to sympathize. The lawyers can still play their games in court, it's free software either way. The fact that a couple central entities get to decide what qualifies as 'real' open source is the most concerning part.

<comment><USER4> > _The lawyers can still play their games in court, it 's free software either > way._

That isn't true at all. If someone takes GCC, makes some changes and re- releases GCCv2 as closed source, there's no open source boogeyman that will force GCCv2 developers to release their code. It's up to courts, and by extension lawyers. Free software implicitly depends on lawyers to hold up the contract of Free Software.

If lawyers tell you "this contract is unusable because of this clause" then you don't have free software, you have a weird proprietary license. The entire point of free software licenses is to define rules for lawyers to play "their games in court". It's worthless otherwise.

<comment><USER5> IMO, the fact that lawyers can't even agree on the scope of the AGPL means that semantics are just that, semantics.

Many licenses haven't been tried in court, including the AGPL, yet it's used fairly broadly.

<comment><USER6> AGPL is widely avoided by corporations precisely because of this problem...

Corporations vastly prefer BSD/MIT style licenses or at most GPLv2.

GPLv3 is avoided, AGPL is avoided even more.

<comment><USER7> AGPL is avoided because cloud/server corporations know exactly what it means. It's expressly written to ban their business models.

Likewise for GPLv3 and Tivoized corporations.

</comment></comment></comment></comment></comment></comment></comment><comment><USER8> > The Software shall be used for Good, not Evil.

It's so funny because Crockford is one of the most persuasive speakers and coders on avoiding ambiguity, on readability over coders desire to "express themselves" in code, and on making language design decisions based on research.

He then takes a step outside his area of expertise and chooses to express himself with an ambiguous license created without consulting anyone who has domain expertise in software licensing.

<comment><USER9> He also made some strange linguistic choices in his latest book[1]:

"The word for 1 is misspelled. I use the corrected spelling wun. The pronunciation of one does not conform to any of the standard or special rules of English pronunciation."

[1] [https://howjavascriptworks.com/sample.html](https://howjavascriptworks.com/sample.html)

<comment><USER10> Side note but that is the best typography I've ever seen in an HTML document.

<comment><USER11> There are a few latex mimicking CSS styles with a similar vibe, I suggest having a look at those

</comment></comment></comment></comment><comment><USER12> I have found it funny that Douglas Crockford apparently gave IBM this exception: "I give permission for IBM, its customers, partners, and minions, to use JSLint for evil." (for JSLint, which JSHints was forked from): [https://web.archive.org/web/20170722132351/https://dev.hasen...](https://web.archive.org/web/20170722132351/https://dev.hasenj.org/post/3272592502/ibm- and-its-minions)

</comment><comment><USER13> > _The Software shall be used for Good, not Evil._

I get that software developers add these things to licenses in good humor, but lawyers have no humor unfortunately. If you want your project to be used in a serious way, it's better to leave the ambiguous phrases out of your license and choose something standard.

<comment><USER14> Well, JSON is used in a serious way, in fact I doubt you can use most web applications (and many desktop apps too) without your machine parsing some json. And... [https://www.json.org/license.html](https://www.json.org/license.html)

<comment><USER15> But JSON isn't software, it's just a specification. Any text that matches the specification is JSON, whether it is binary, a string, printed on a piece of printer paper, etc. So what does this license mean, exactly?

<comment><USER16> The JSON License was created to cover the original Crockford JSON parsing and linting libraries.

</comment></comment></comment></comment><comment><USER17> > ...licensing concerns. That's why Ubuntu users can't download JSHint via > sudo apt-get install jshint.

Okay, this is misleading. You can install tons of non-free packages using apt from the official archive. They are in the multiverse section.

[http://archive.ubuntu.com/ubuntu/pool/multiverse/](http://archive.ubuntu.com/ubuntu/pool/multiverse/)

</comment><comment><USER18> I've also had customers dig their feet in because I depended on this library: [https://dst.lbl.gov/ACSSoftware/colt/license.html](https://dst.lbl.gov/ACSSoftware/colt/license.html). Exactly when what you're doing is considered a military application is ambiguous. Have an obscure DoD contractor as a customer? Uh oh - can't use this...

</comment><comment><USER19> Sorry for commenting on the formatting instead of contents, but how could someone say "The following graph shows how many times JSHint has been downloaded from npm each week over the past five years" and then present a graph with four data points?

Frankly that makes me doubt the author's central piece of evidence (that JSHint gets much fewer downloads than ESLint).

* Graph from this URL in case it changes again: [http://mikepennisi.com/blog/2020/jshint-watching-the-ship-si...](http://mikepennisi.com/blog/2020/jshint-watching-the-ship-sink/)

<comment><USER20> Here's a better set of charts, using the `npm-stats` site:

[https://npm-stat.com/charts.html?package=jshint&package=esli...](https://npm- stat.com/charts.html?package=jshint&package=eslint&from=2015-01-01&to=2020-08-04)

</comment></comment><comment><USER21> Writing software is not a neutral act. You are morally responsible for its uses. Restricting those uses is both a responsibility and a good. Circumventing this restriction is itself an immoral act.

<comment><USER22> > Writing software is not a neutral act. You are morally responsible for its > uses.

That's an unsound argument - it suffers from a confusion of agency. The most I can be responsible for as an author is the _intent_ of my software.

If I'm a wrench manufacturer, I have no moral obligation to attempt to control how people will use my wrenches. They are amoral tools with a good intent (to help with construction projects). Whether my wrenches or those projects will end up being used for evil is beyond my purview.

<comment><USER23> This I would generally agree with. However, care should be taken with powerful tools – deepfake software, explosive material, and so on. The laissez-faire "guns don't kill people" attitude isn't wrong, per se, but it can be inconsiderate if used blindly.

<comment><USER22> True, but I think your caveat is covered by my assertion regarding the intent of the tool.

The intent of deepfake software is clearly either fraud or development of deepfake detection tools. If you're a vendor and your intent is the latter, it would be morally commendable to do your best to sell to reputable customers only... but with security tools like this the authorial intent almost doesn't (and shouldn't) factor in. Unfortunately, if you try to go soft so it won't "hurt someone" then the fraud detection R&D can't be as robust.

Regarding guns, they're either for killing people, killing varmints/animals, or defending oneself against bad guys. As a salesperson, you can reserve the right to refuse sales to known crooks -- that would be morally commendable (as far as it's possible). But it's your decision based on your own judgment. As far as the gun itself is concerned, if as a manufacturer your intent is defense against bad guys (or legal hunting/varmint control) and your product reflects that intent, then you're morally in the clear.

Incidentally, I'm strongly against sales of surplus military gear to police departments, because of the mixing of intentions that are at-odds. The intent of military gear is to fight foreign armies commanded by bad guys -- which is an intent that police departments should never have, as they're dealing with civilians. That's why in the US, we have the National Guard if an army of bad guys ever appears within our borders--it's different from the police, with different training and different _intent_.

<comment><USER24> "The intent of deepfake software is clearly either fraud or development of deepfake detection tools. "

I think there are a ton of positive, creative uses of it. For instance de- aging an actor for a flashback sequence, with their permission. Deepfake software can potentially do this way cheaper than the state of the art, such as the young Tony Stark / Peter Quill's dad / Leia. And eventually, it should be able to do it better. When the technology is truly indetectable, it will be used all over the place in filmmaking and even video games.

<comment><USER25> Do we need to consider only intent, or can we extrapolate probable futures?

Because then I worry about deepfakes making actors obsolete (as we have made obsolete so many other professions)

<comment><USER24> Maybe I'm older than you, but I remember being worried about those newfangled bulldozers making us ditchdiggers obsolete. :)

Or how about movies making stage actors (and set builders, etc) obsolete? I mean, when you only have to act it out once and millions can see your performance, as opposed to actors performing shows every night in small venues in towns all over the country, it puts a lot of people out of work. There are pretty few people today making a living as actors.

And of course photography put portrait painters out of work. And high quality cameras in cell phones probably put a lot of photographers out of work.

What might happen is that there will still be actors, but all they have to do is act, not be beautiful. They can use a model for the beautiful part. And then you can have talented people on computers merging it all together.

I do like the idea of bedroom production of movies, which can happen if you don't need actors. Previously, if you want to be a film director, you needed to be born into a rich family, and then after extremely expensive film school, you needed to get big money to finance your movies. So there's that.</comment></comment></comment></comment></comment></comment></comment>


Scientists Unlock Cocoa Genome, Release to Public Domain - <AUTHOR> http://www.reuters.com/article/idUS318992028620100915 <comment><USER2> There are many other projects releasing genome as public domain:

\- <http://www.arabidopsis.org/> \- ftp://ftp.arabidopsis.org/home/tair/Genes/ Arabidopsis thaliana , a well-known plant in the botanical community.

\- NCBI/NIH ftp://ftp.ncbi.nih.gov/genomes/ where you have the genome of some well-known bacterias or the famous Drosophila fly

and if you want more readable interface to the Genome, you have websites like <http://www.uniprot.org/> to navigate in various genomes.

</comment><comment><USER3> Soon: renegade geneticists develop bacteria that produces cocaine.</comment>


Go Program Crazy Stone defeated Yoshio Ishida, a professional Go player - <AUTHOR> http://www.newyorker.com/online/blogs/elements/2014/03/the-electronic-holy-war.html

<comment><USER2> Interesting story. I spent a lot of free time in the late 1970s and early 1980s working on my Go playing program Honninbo Warrior (played poorly, but was the first commercial Go playing product).

The new Monte Carlo search technique (used by Crazy Stone) basically blows all previous approaches out of the water. I bought the "Championship Go" app for my android phone, it uses Monte Carlo, and plays well.</comment>


PG: The hundred-year language - <AUTHOR> http://www.paulgraham.com/hundred.html

<comment><USER2> If you name your language 'The hundred-year language' then you are asking for people to do two things:

\- misinterpret you

\- be underwhelmed with your performance

Something like that requires full time dedication of at least one person during the initial phase (say two decades or so), and after that an opening up.

By putting arc out there before it's 'ready' there is an upside, you get feedback from the community. But you also get an installed base and pressure to perform, and that's a drawback.

The haskell community has this motto: "avoid success at all costs". It took a long time to get haskel to be where it is today, and that has a lot to do with their motto. But it was the way to keep it clean and consistent. And arc was/is meant to go for the same if I understood it all right.

You can move fast in the programming language field, but then you'll have to be 'practical' and 'compromising'.

Or you can move slow, but then you risk 'irrelevant' and 'theoretical'.

A 'true' one hundred year language would try to strike a median between the two, it would be developed with a resasonable speed by a really small, core team that was very dedicated to the work.

Arc answers some interesting questions (it's essentially a better lisp), but it has one more drawback compared to lisp, which is that there is only a very small community behind it. This stops it from gaining widespread acceptance, but that is actually a benefit if you want to stay flexible.

But the window of time that you have to remain in that mode is not infinite and I think that the speed at which arc is coming along is mostly driven by improving HN (scale, features) than the other way around.

If HN were to move to say clojure (I know, that's cursing in the church, but I think it is one of the more realistic options when it comes to dealing with growth) then all the drive to keep arc going would be more or less lost.

A programming language for a community of '1' is a hobby project, but if HN came out of 'arc' then in a way the project has already succeeded, just not in the way that it was originally planned.

My longer term prediction is that clojure will occupy the niche that Paul described with the '100 year language', it's also based on lisp, it's headed by one very smart guy that is willing to work with a team of people providing input, it's gaining adoption fast and it solves some very pertinent problems (multi-programming, how to bring the functional paradigm to the web, STM) in elegant ways. And putting it on top of the JVM was sheer genius.

Time will tell, 97 years to go.

<comment><USER3> I think you're mistaken that marketing (in the sense of community building) is an important component of designing a language people would still care about in 100 years. The history of the Lisp family is a counterexample. For 50 years (except arguably for a brief interlude in the 1980s) Lisp was popular only with a tiny community of eggheads. Now thanks to Clojure Lisp is fashionable.

The history of such fashions also contradicts your claim that you can lock in a position of leadership by building a big community around your language. There has been new hot language every 5 years. First Perl, then Python, then Ruby, now maybe Clojure.

The way to make a language popular in the short term is build buzz and libraries, because that's what the average programmer cares about. But to build a language that turns out to be the ancestor of whatever people are using in 100 years, you have to appeal not to programmers but language designers. You have to create the ideas language designers want to copy (have to copy, because you found the optimal solution). That's what McCarthy did.

</comment></comment><comment><USER4> _At any given time, you're probably happiest on the main branches of an evolutionary tree. Even when there were still plenty of Neanderthals, it must have sucked to be one. The Cro-Magnons would have been constantly coming over and beating you up and stealing your food._

I think you might want a little more justification. This principle implies you would be happier as a rodent like thing then a dinosaur. It might be true, but it is not self evident.

</comment><comment><USER5> I think creating a 100 year language would be cool, if it weren't for the fact that some geeks are the most fickle people in the world, who jump on the latest fad. They don't want a "100 year language", they want "The new awesome thing". Then 3 years later they want the next fashionable thing to be using.

At the end of the day, it doesn't really matter that much. It's just fashion.

<comment><USER6> You are confusing actual programmers with web 2.0 fanbois with blogs. Some people value stability and incremental improvement, but those people don't seem to write as much as the "throw everything away and use this language I read about on /b/ last night".

There is probably not a market for the 100 year language, as we don't know enough about programming to predict that far into the future. But all the languages we use today are probably "25 year langauges", which is getting there.

<comment><USER5> Yeah you're probably right about the fickle people being far more vocal than the ones just using the same language.

I'm not convinced languages are really something that need constant improvement and evolution though. There's a lot to be said for all generally using the same language over a long period of time. I'd say that's more important than which particular language it is.

A language exists to communicate ideas. Obviously you don't want a language that is ambiguous, or overly verbose. You also want a language that can express most ideas you want to express in a simple way.

But IMHO, that's been achieved already - several times over. If we never improved any computer language, and just continued using the ones we have, we'd still be able to express the ideas we have in them.

I agree @ 25 years. Further than that, maybe we won't use any programming languages at all. Who knows.

</comment></comment></comment><comment><AUTHOR> Awesome quote :)

> Object-oriented programming offers a sustainable way to write spaghetti code

<comment><USER7> It is interesting that Rich Hickey shares this opinion as well (he considers OOP spaghetti code) and both of them are developing new lisp dialects!

<comment><USER6> And it's odd that they both replace it with something exactly equivalent.

</comment></comment></comment><comment><USER8> For certain domain of problems SQL is the 100 year language. You have to define tables and indexes but you don't get to chose how joins are performed - query optimizer knows about your high-level request to chose optimal execution strategy most of the time. It's a small leap from there (in historical terms) to make the indexes built automatically via profile-guided-optimization.

Similarly, Flex is the 100 year language for UI. It's almost entirely devoid of implementation details and you get to spend most of your time describing what you want to see. What Flex is for Flash, open OpenLaszlo is for HTML.

</comment><comment><USER9> I find the notion that Java could be considered an evolutionary dead end bizarre, considering that it achieved the commercial and mindshare breakthrough for garbage collection and VMs.

In fact, looking at current developments, it seems not unrealistic at all to predict that whatever languages we'll have in 100 years, many of them will be running on a direct descendant of the JVM.

<comment><USER10> Java (the language) != JVM

There are plenty of good languages for the JVM (Clozure, Scala, ...), but Java is not one of them.

<comment><USER9> Still, without the widespread success of Java, the JVM as we know it would not exist or would at least not have seen widespread adoption. Thus all languages running on it are, if not sons and daughters, at least nieces and nephews of Java.

<comment><USER11> Actually, clojure sounds more like the dude that lives in java's basement, and uses java's bathroom.

</comment></comment></comment></comment><comment><USER12> The 100 year language is the language that will finally make the business guys in a startup feel like they can also program.

<comment><USER2> They already do, at least whenever I hear business types say that X or Y should be really easy I always wonder if they're ever to be in hospital to get surgery if they're going to tell the surgeon as well what should be easy or hard.</comment></comment>


Coronavirus State Actions Dataset - <AUTHOR> https://www.dolthub.com/blog/2020-04-13-corona-virus-state-actions-using-pull-requests/ <comment><AUTHOR> I'm a software engineer at Liquidata ([https://www.liquidata.co](https://www.liquidata.co)), the creators of Dolt and DoltHub. I recently published this blog that describes a coronavirus state actions dataset we made based on NGA's State Action Tracking Chart and how we used pull requests on DoltHub to improve this data.

Blog: [https://www.dolthub.com/blog/2020-04-13-corona-virus- state-a...](https://www.dolthub.com/blog/2020-04-13-corona-virus-state- actions-using-pull-requests/)

View or clone the dataset: [https://www.dolthub.com/repositories/Liquidata/corona- virus-...](https://www.dolthub.com/repositories/Liquidata/corona-virus-state- action)

NGA State Action Tracking Chart: [https://www.nga.org/coronavirus/#states](https://www.nga.org/coronavirus/#states)</comment>


Computer Vision for Python - <AUTHOR> http://code.google.com/p/ctypes-opencv/

<comment><USER2> I have these other links for interfacing openCV with python:

<http://opencv.willowgarage.com/wiki/PythonInterface>

[http://wwwx.cs.unc.edu/~gb/wp/blog/2007/02/04/python- opencv-...](http://wwwx.cs.unc.edu/~gb/wp/blog/2007/02/04/python-opencv- wrapper-using-ctypes/)

<http://www3.ntu.edu.sg/home5/pham0004/pycv/> "A Computer Vision Package for Python Incorporating Fast Training of Face Detection"

[http://www.instructables.com/id/Using-openCV-1.0-with- python...](http://www.instructables.com/id/Using-openCV-1.0-with- python-2.5-in-Windows-XP/)

</comment><comment><USER3> I used Python + OpenCV during my MSc for face-detection: <http://littlespikeyland.com/msc/project/> back in 2003/2004, so I ended up doing a lot of SWIG wrapping. A lot of the heavy lifting was done in C/C++, as I was running lots of simulations for a evolutionary algorithm.

I've used ctypes for a few projects now and wish I could have used it for that project. Might have meant I could have ditched a lot of the C/C++.

</comment><comment><USER4> Great find, I had been looking into trying to extend the PIL to support some CV features; had no idea that this was out there.

God, I really could've used that sample K-Means algorithm during last semester when I was taking DIP.

</comment><comment><USER5> How can it be a pure Python package? Surely you need something of openCV installed. Am I reading it wrong?

<comment><USER6> It's a Python interface to OpenCV's shared libraries. You still need the OpenCV binaries to be installed, though not necessarily the source.</comment></comment>


The Next Major Version of Firefox is Ready to Test - <AUTHOR> http://blog.mozilla.com/blog/2011/01/14/the-next-major-version-of-firefox-is-ready-to-test/

<comment><USER2> The linked page is currently down, however you can see release notes here: <http://www.mozilla.com/en-US/firefox/4.0b9/releasenotes/>

Or, there's a style-less Google cache of the actual blog post: [http://webcache.googleusercontent.com/search?sclient=psy&...](http://webcache.googleusercontent.com/search?sclient=psy&hl=en&client=firefox-a&hs=5VJ&rls=org.mozilla%3Aen- US%3Aofficial&source=hp&q=cache%3Ahttp%3A%2F%2Fblog.mozilla.com%2Fblog%2F2011%2F01%2F14%2Fthe- next-major-version-of-firefox-is-ready-to- test%2F&btnG=Search&aq=&aqi=&aql=&oq=&pbx=1)

<comment><USER3> It was down for a short while (don't launch software on a US long weekend ;), but is back now.</comment></comment>


wswatch: Unix watch(1) in the browser (Node.js, WebSockets) - <AUTHOR> https://github.com/jzwinck/wswatch

<comment><AUTHOR> I made this. It's a little bit like the program discussed here last week: [https://news.ycombinator.com/item?id=6879667](https://news.ycombinator.com/item?id=6879667)

This lets you use a web browser (or multiple browsers) to view the current output of a command, updating in real time. An old-school idea with a new twist.</comment>


Show HN: New Engine – Play Chess Without Moving Pieces - <AUTHOR> http://ba.net/guesschess/ <comment><USER2> Previous submission, 27+ comments:

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

<comment><AUTHOR> New chess engine fixes the main problems that came up on the last discussion thread</comment></comment>


JuliaCon2020: Julia Is Production Ready - <AUTHOR> https://bkamins.github.io/julialang/2020/08/07/production-ready.html <comment><USER2> Invenia had run Julia for our primary production system for over a year (nearly 2).

The size of our Julia codebase is about 400,000 lines of code, spread over numerous internal and open source packages. You can cite the "we're hiring" slide from my Juliacon talk for that [https://raw.githack.com/oxinabox/ChainRulesJuliaCon2020/main...](https://raw.githack.com/oxinabox/ChainRulesJuliaCon2020/main/out/build/index.html#2)

<comment><USER3> I'd be super interested in having you (or someone at Invenia) on as a guest on a podcast that talks about tech stacks. We'd cover things like what development and deployment is like, which tools you use and why you chose them, etc..

At the moment there's no Julia episodes yet. If you want to come on, head over to [https://runninginproduction.com/](https://runninginproduction.com/) and click the "become a guest" button near the top right to get the ball rolling.

<comment><USER4> Oh, that would be awesome! I would really love to listen to a bit more detail about the choice of Julia for a company's stack. (I am an academic, so choosing Julia was very easy for me :) but I can imagine this choice could likely be harder outside of basic research.)

</comment></comment></comment><comment><AUTHOR> People often ask me for examples of non-scientific Julia codebases. My favourite one is Franklin.jl ([https://franklinjl.org](https://franklinjl.org)), a static site generator. This blog discusses quite a bit more, and it doesn't even talk about all the improvements in integrating with databases and such.

<comment><USER5> Another example is that all the infrastructure for serving Julia packages to Julia users in the new 1.5 release is implemented in Julia. This is a content distribution network served by highly concurrent servers over HTTPS. The systems interacts with git servers, GitHub APIs and AWS S3 among many other moving pieces. Code can be found here: [https://github.com/JuliaPackaging/PkgServer.jl](https://github.com/JuliaPackaging/PkgServer.jl).

Writing servers in Julia is really pleasant thanks to the clean coroutine- based task model. Under the hood, Julia uses libuv to get efficient high- concurrency I/O with an event loop. But from the user's perspective, you just write simple blocking code and use `@sync` and `@async` to spawn concurrent tasks. If you want to use multiple threads, just use `@spawn` instead of `@async`. This is very similar to Go's highly successful I/O and concurrency model.

<comment><AUTHOR> That's a great example. Also, JuliaBox.com (discontinued service) ran on Julia in production for 3 years, and has now been replaced by JuliaHub.com, which is also largely written in Julia.

Several Julia Computing customers also run long running Julia jobs in production, and some are discussed in our Case Studies ([https://juliacomputing.com/case-studies/](https://juliacomputing.com/case- studies/)).

</comment></comment></comment><comment><USER6> I've been thinking about jumping on the Julia ship for a while. I like the LISP-like nature of R and miss its flexibility very much while working in Python (a language I also enjoy, but not particularly for data science). Julia, specifically its macro story and speed, fascinate me.

One of the things that still keeps me at bay is the JIT and the pre- compilation in general. It seems like it's still not very easy to actually compile a Julia library or an executable. There is PackageCompiler.jl, but my understanding is that it necessitates pulling in sys.so, which is some 130 MB in size, making it prohibitive for many projects.

<comment><AUTHOR> We are always working on streamlining PackageCompiler.jl and building binaries. Bug reports always appreciated.

I'm curious to understand why the 130MB is prohibitive. Are you looking at embedded or resource constrained environments?

<comment><USER7> In a few use cases, such as big-data processing and things like that, a common pattern is to haul a tiny data-processing kernel to several machines to do an operation on some data they hold, rather than shuffle the data around.

This pattern can be seen in several places and frameworks like Spark & company, and it's also pretty much the foundational idea behind processing data with Joyent's Manta[0]. It always pretty much boils down to "serialize a function, and send it somewhere, to run on the data locally".

Some of these frameworks do it only through native functions (Spark runs serialized JVM procedures, and for Python functions I believe it shells out to an actualy Python interpretes), others are completely agnostic to this and work with binaries (Manta).

It'd be pretty hard to do, and have a lot of overhead, if all of those "functions" that I'm shuffling around are, at the lower bound, 130MB in size.

I understand that a lot of this can be done directly at the Julia layer for Julia things (much like Spark does with JVM things), but it kinda limits the applications of this nonetheless.

[0] [https://github.com/joyent/manta](https://github.com/joyent/manta)

<comment><AUTHOR> Julia can already do this in its `remotecall` API (actually has done this since v0.1), which serializes a closure and sends it to a remote node for computing.

[https://docs.julialang.org/en/v1/manual/distributed- computin...](https://docs.julialang.org/en/v1/manual/distributed-computing/)

However, this is not related to the system image (sys.so) that is used to start the Julia process, which has a compiled version of base, stdlibs and whatever else you choose to build in.

</comment></comment></comment></comment><comment><USER8> Julia is next gen. The whole experience is so much more pleasant than anything in the space. The interop is also crazy. How is it possible that you can call Matlab, Python, cpp, fortran, Rust from one language?

I legit think that even if you are using say pytorch. You are better off writing your code in julia and using the python interop.

<comment><USER9> Yeah, the quality of the language is pretty incredible. Especially compared to Python, which has been a disaster for as long as I can remember.

I think the ecosystem could be a bit better, but that's more of a personal opinion rather than a serious concern as, like you alluded to, you the interop story is insanely good.

<comment><USER8> The ecosystem is moving very rapidly though. What do you think is missing?

<comment><USER9> Right now, the DataFrame package doesn't support row indices like Pandas does. Row indices are especially useful time series data, and there's another package called TimeSeries that support a dataframe-like type called a TimeArray that supports dates as row indices.

TimeArray is like a DataFrame, but with a lot less features. You can't really do that much with them, and they only have limited support in an auxiliary package for resampling.

It would be nice if a new DataFrame library could be created that was inspired by Pandas.

In general, I think Julia suffers from the problem of too many small packages. For example, there's 3 libraries I have to use for time series: TimeSeries.jl, TimeSeries Resample.jl,and TimeSeriesIO.jl. None of the libraries are particularly large and should all be merged into one package.

Part of the reason for the dirth of small packages is because, unlike Python, Julia's strong support for function polymorphism allows for seamless extension of existing functionality with new packages. Unfortunately, I think this has created a cultural problem in which new packages are created that only slightly modify existing functionality.

<comment><USER10> Please don't be "inspired" by pandas.

<comment><USER9> No, you're right. Pandas totally sucks. But the one good thing it got right is support for row/multi-index.

</comment></comment></comment></comment></comment></comment><comment><USER11> While being a big fan of Julia in general and recognizing a very significant progress in both language and ecosystem development [kudos to Julia's core team as well as numerous contributors to the language and its growing ecosystem!], I respectfully disagree with the post's author conclusion in its entirety.

For scientific computing and advanced machine learning domains, Julia is certainly a breath of fresh air and a no-brainer decision. However, as a general-purpose language as well as technology stack, I think Julia has still a long way to go. This is mostly due to relative immaturity of that part of the ecosystem, spotty - and sometimes even non-existent! - documentation (of course, except for the language itself and quite a limited number of core and popular packages) as well as some other issues, including tooling, development/compilation performance and limited pool of skilled developers.

So, from a startup founder perspective [who has to select the optimal, risk- minimizing, platform stack], despite Julia's many attractive features (including powerful meta-programming facilities - in my case, for potential DSL development), I'm now leaning toward Python and .NET ecosystems. Both offer very mature and large package ecosystems along with comprehensive tooling support and incomparably larger pool of skilled developers. Additionally, .NET offers stability of consistent development improvements, backing of a major corporation [no acquisition risk] along with support for modern enterprise-focused architectural practices and patterns, including DDD and multi-tenancy.

<comment><USER12> This.

Not trolling. I don't really know why people like to shoehorn a purpose- oriented language into all domains. Eg: Julia for scientific computing, Rust for low level programming. They would be great if they focused on those "strong zones".

<comment><USER13> I read this article not as a "Julia is ready to replace the all-purpose languages used in business", but as "Julia is ready to deploy it's scientific computing into production environments" (as opposed to just local/hobby tasks and academic environments which were the early focus). No one is recommending people to do their small e-commerce in Julia (or perhaps Rust) unless you're in for the fun of the languages (or your e-commerce happens to be a special case that will play with either language's strengths). But having a solid web deployment story is important to both regardless, be it in Julia to have live dashboards or integrating your scientific models in your microservice architecture and to serve them directly to clients or Rust for embedded web servers for IoT and other devices. For a language to be great in one domain, it has to be at least good in everything around it for when you need to connect that domain to the real world.

And Julia creators do focus on it's strong zone, with all the works on TPU, HPC and parallel computing, and so does the community with the stuff presented in juliacon like interactive reproducible notebooks (Pluto.jl) or data dashboards (Stipple.jl), both using the web domain to improve the scientific computing domain.

<comment><USER11> I'm not disagreeing with most of your comment above, except for how the post reads. To be accurate, the post's author set the _context_ to _general-purpose computing_ , not the scientific one. Here are two arguments for why I think so.

1\. Intro section (italics emphasis mine).

"... delivering _complex enterprise projects_ :

        Julia is fast, and has a very nice syntax, but its ecosystem is not mature enough for use in serious production projects.

For many years I would agree with it, but after JuliaCon 2020 I believe we can confidently announce that

        Julia is production ready!"

2\. Section "Building microservices and applications". Even more so, practically all sections in the post, except just one ("Managing ML workflows"), describe various general-purpose and enterprise computing aspects.

Therefore, I don't see how one could view the post and author's conclusion purely from scientific computing perspective.

<comment><USER13> Fair enough, it might be my own view on what I'd use Julia in a production environment clouding my interpretation of the scope of the text, especially as the author defines this as his area at the start and says how it's what Julia shines at. Julia being an acceptable ("production-ready") language means that whenever my problem hit the areas that Julia shines, it becomes a valid candidate to evaluate considering all pros and cons.

And while right now I wouldn't recommend Julia for that web domain unless you also need it's number crunching features (which is more than just scientific computing, I work with large finance systems and there is definitely a lot of that stuff), I do think it's more of a library/community problem than a language problem. The language is well equipped to handle it (easy to use from a scripting perspective, easy parallelism, fast after warm-up, allows for clean abstractions to create sophisticated web frameworks, the mentioned easy FFI), what it lacks is the coverage and maturity of the tools and support (so I don't feel like I'm at a risk at any point that I need to do some integration, such as integrating with Kafka or any other systems, without having to write my own solution or integrating multiple languages at every step).

That's different from systems programming, embedded, game development and even GUI development (at least until smaller binaries with less warm-up) right now. Even with good library it will not be competitive with the languages that already claim those domains. Julia is a general purpose language already and more than a matlab substitute, it does not need to be good at everything (and it shouldn't try), but I don't think it should restrict the scope too much either.

<comment><USER11> I appreciate your thoughtful comment. Clearly, we are on the same page on the topic at large. As mentioned in my original comment above, I see no problems with Julia language per se (quite the opposite - I find it elegant, flexible and powerful), but rather emphasized that present issues exist around relevant ecosystem (documentation, packages, tools and support).

</comment></comment></comment></comment></comment></comment><comment><USER14> I can currently see Julia only as a replacement for Python, with the biggest advantage, that fast modules can be written in-language, and you do not default back to C. So in a sense it could solve the two language problem.

But then for my applicationsspace there are problems:

\- compilation seems possible now, but one has to be careful of GPL (like in the fft)

\- no way to turn off GC (so byebye real-time possibilities).

\- what about GUI design? Heard some mixed messages about it

<comment><USER15> > \- no way to turn off GC (so byebye real-time possibilities).

While Julia does not offer semantic guarantees that you can avoid the GC, it;s actually quite possible and easy to write code where you're manually managing all your memory and the GC is never invoked.

> \- what about GUI design? Heard some mixed messages about it

There's a lot of promising things happening with Makie.jl, Stipple.jl, Dash.jl, Pluto.jl and others. This space is still a little immature in Julia, but it's progressing fast.

<comment><USER14> I know there are workarounds, but when you do not have guarantees the phrase 'production ready'is not the first that comes to my mind. (Of course in the problem spaces of matlab and python, and probably R, Julia is probably on par)

<comment><USER16> Well, how high is the bar for calling a language 'production ready' in that case? How many production ready languages are there?

<comment><USER14> What I meant: production ready depends on the feature. So for substituting Python (and beeing able to write fast in-language extensions), the language is most likely production ready; so in a sense it is a replacement for Python + C; but not a replacement for C. And this is a bit sad, because it could have been (building linked executables should be possible, since the language is compiled).

But I like your question, lets call it 'which languages are all purpose production ready'; probably only C, C++, Java (there is a real-time version), LabView.

</comment></comment></comment></comment></comment><comment><USER17> Having followed it since the 0.4 era I'm excited that Julia is production- ready (though I have professionally moved to elixir). Since I'm working in ml infra, I'm interested in orchestrating Julia jobs (via Elixir), what I'm less clear on is if there are good resources on how to deploy Julia, keep dependencies sane, pin memory usage. Or does one just go straight to containers?

<comment><USER18> Yep, to build on Stefan's sibling comment, we deploy a few services through docker that follow the flow of <merge on github> -> <build on dockerhub> -> <deploy through watchtower> that has been working for us really well.

Docker has some nice infrastructure that we like, such as the ability to set memory limits, automatically restart processes on crash/if a healthcheck goes sour/on reboot, easily spin up different versions of the same service (based on which image you tag to a name), etc... Containerization has done a lot for our ability to bring servers up onto heterogenous hardware easily and quickly.

As an example, this repository [0] is deployed on 10 machines around the world, providing the pkg servers that users connect to in geographically- disparate regions. The README on that repository is a small rant that I wrote a while back that walks through some of the decisions made in that repository and why I feel they're good ones for deployment.

To answer your specific questions:

* How to deploy Julia: we use docker containers and watchtower [1] to automatically deploy new versions of Julia.

* Keep dependencies sane: it's all in the Pkg Manifests. We never do `Pkg.update()` on our deployments, we only ever `Pkg.instantiate()`.

* Pin memory usage: We use docker to apply cgroup limits to kill processes with runaway memory usage [2]. This is only triggered by bugs (normal program execution does not expect to ever hit this) but bugs happen, so it's good to not have to restart your VM because you can't start a new ssh session without your shell triggering the OOM killer. ;)

[0] [https://github.com/JuliaPackaging/PkgServerS3Mirror](https://github.com/JuliaPackaging/PkgServerS3Mirror) [1] [https://github.com/containrrr/watchtower](https://github.com/containrrr/watchtower) [2] [https://github.com/JuliaPackaging/PkgServerS3Mirror/blob/c6a...](https://github.com/JuliaPackaging/PkgServerS3Mirror/blob/c6ae2c8e9a7b228cebbcf48c25fd2381be97b565/docker- compose.yml#L18)

<comment><USER5> With a bit more detail, this would make a great blog post!

</comment></comment></comment><comment><USER19> I really enjoyed the workshops and the talks; I thought the SciML and MLJ talks were particularly good.

Everything is available on their YouTube channel:

[https://www.youtube.com/playlist?list=PLP8iPy9hna6Tl2UHTrm4j...](https://www.youtube.com/playlist?list=PLP8iPy9hna6Tl2UHTrm4jnIYrLkIcAROR)

</comment><comment><USER20> Is the debugger in Vs code or anywhere else better now? I remember trying Julia just a few months ago and the debugger frustrated me enough that I went back to print statement debugging.

<comment><USER21> I'm not using Julia actively, but I've been following the news and I there was a lot of improvements made to the VS Code extension, and better debugging experience as one of them. You should try it out again.

</comment></comment><comment><USER22> If you were trying to motivate someone embedded in Python / scipy / pandas / etc to move to Julia at this time , what would you say?

<comment><USER15> I think this post: [https://julialang.org/blog/2012/02/why-we-created- julia/](https://julialang.org/blog/2012/02/why-we-created-julia/) presents the aims of the Julia project at a high level quite well. That post was partly aspirational at the time, and partly already achieved.

Now, 8 years later, I'd say essentially everything there has been achieved. The most important difference between Julia now and Julia then is the gigantic, vibrant and interacting ecosystem that's sprung up (though share are other important technical differences too!)

_______________________________________________

Here's the pitch I'd give:

Julia's value proposition is mostly geared towards people trying to do things that are just too difficult, awkward or slow in other languages. It's not just about speed, dynamism and friendly syntax. It's also about solving the expression problem and providing unprecedented composability.

So while it may not necessarily have great appeal to 'end users' (who are people just calling numpy/scipy/pandas/whatever functions the way they were meant to be called by the library writers), it does appeal to people who make the sort of things end users want so the community is currently swelling with very talented people making state of the art research libraries. The language is designed for 'composability', so that it's very easy to combine packages together in ways the authors didn't necessarily intend or forsee.

This approach is really starting to bear fruit. Our package ecosystem has some real, state of the art stuff not easily available in other languages, and it's often built in less time and with less resources. For 'end users', whether or not Julia makes sense for them really just depends on if the things they need are already available.

Another huge advantage is that even if you're not some super researcher developer, Julia substantially lowers the bar for mere mortals such as myself to do package development. The composability I mentioned above means that I can stand on the shoulders of giants as I implement my own stuff, plus the fact that the majority of libraries are written in pure julia means that I can easily "peek under the hood" to figure out how they work and learn from them. This is really special and can't be replicated in python, because 'peeking under the hood' invariably means reading very specialized C code, rather than Python code.

I think Julia will someday eat Python for scientific computing, but it may be a while before that becomes obvious to Python users. In the meantime, we have an _excellent_ package for calling and running Python code from withing Julia, called PyCall.jl [1], so that can make the burden of switching even easier.

[1] [https://github.com/JuliaPy/PyCall.jl](https://github.com/JuliaPy/PyCall.jl)

<comment><USER23> This is a good pitch and I think composability is the major selling point for programming in the large. Time will tell though if the ecosystem doesn't fragment as different approches or competing packages appear, for political if not technical reasons. The Torch vs TensorFlow choice could have been in Julia.

> I think Julia will someday eat Python for scientific computing, but it may > be a while before that becomes obvious to Python users.

I can't say I understand this rather pervasive attitude. If you have well tested code in a language which you can easily interface with, why bother rewriting it except for reasons of performance or compositionality? Or perhaps you mean that we'll all be writing Julia even if some algorithms still sit in Python?

<comment><USER15> > I can't say I understand this rather pervasive attitude. If you have well > tested code in a language which you can easily interface with, why bother > rewriting it except for reasons of performance or compositionality? Or > perhaps you mean that we'll all be writing Julia even if some algorithms > still sit in Python?

I mostly mean that I think Julia will someday have more mindshare in scientific computing than Python.

However, I'd say that the reason you see the "rewrite it in pure julia" attitude everywhere is that we enjoy a lot of benefits from having more and more things in pure julia, namely that our very powerful metaprogramming and code introspection tools can more easily 'get inside' Julia code, and that the compiler is able to perform interproceedural optimizations (IPO). IPO are not always important, but when you need them and don't have them, you _really_ miss them, so at least for numerical kernels and such, it's really nice to have as much pure julia infrastructure as possible.

In the meantime though, as I daydream about a world where everything is written in Julia, there's nothing stopping me from being pragmatic and wrapping / bridging to and from other languages.

<comment><USER23> I completely agree Julia is fantastic for computational kernel construction. I would like to never again write GPU kernels by hand (though Numba has been quite sufficient for my needs). I just don't see this as everything.

</comment></comment></comment></comment></comment><comment><USER24> Thanks for sharing this. Are there instructor resources available to teach Julia in a data science program? I use R mostly but I am porting one course on ML applications to Python. The communities in both R and Python are vibrant for instructors to create structured learning experiences for data science. How about Julia?

<comment><USER25> [https://juliaacademy.com/](https://juliaacademy.com/) [https://github.com/mitmath/6S083](https://github.com/mitmath/6S083) [https://www.youtube.com/watch?v=R84L-BQcjHw&t=905s](https://www.youtube.com/watch?v=R84L-BQcjHw&t=905s)

<comment><USER24> That's great, thanks!

</comment></comment></comment><comment><USER26> Do you guys know if it's possible to generate self-standing C++ code from Julia code? (i.e., code that you can then compile into another project, and will not require any interpreter to run or anything like that)? And if it's possible do you know how good the generated code is (in terms of speed)?

<comment><USER27> You can create binaries from Julia and there are APIs to call Julia code from C/C++

[https://julialang.github.io/PackageCompiler.jl/dev/devdocs/b...](https://julialang.github.io/PackageCompiler.jl/dev/devdocs/binaries_part_2/)

[https://docs.julialang.org/en/v1/manual/embedding/](https://docs.julialang.org/en/v1/manual/embedding/)

</comment></comment><comment><USER28> Does the Julia matrix has named columns as R or unnamed as numpy?

<comment><USER13> The built-in array (which is multidimensional) is unnamed, but Julia was made in a way that anyone can create as a library their own types that are as high performance as the native ones (most of which are written in Julia) so you can just get a named array package like [1].

[1] [https://github.com/davidavdav/NamedArrays.jl](https://github.com/davidavdav/NamedArrays.jl)

</comment></comment><comment><USER29> Julia feels like a good replacement for Matlab, but then Matlab have Simulink, is there any project to create something like Simulink but for Julia?

<comment><USER30> Something ModelingToolkit.jl, JuSDL.jl, NetworkDynamics.jl, Modia.jl, etc. all are extensions of Simulink in some form. Supporting stochastic equations, delays, automatic parallelization, acausal modeling, etc.

</comment></comment><comment><USER28> What is the state of data frame support in Julia?

<comment><USER31> Exceptional — and its lead author is the author of this blog post.

[http://juliadata.github.io/DataFrames.jl/stable/](http://juliadata.github.io/DataFrames.jl/stable/)

<comment><USER32> Is that what you meant to link? It looks like the official docs, and not a blog post.

<comment><USER33> This post is also relevant: [https://bkamins.github.io/julialang/2020/08/02/post_juliacon...](https://bkamins.github.io/julialang/2020/08/02/post_juliacon_1.html)

Edit: it's a bit more into the weeds than I thought. Honestly the docs give a better picture of DataFrames.jl

</comment></comment></comment></comment><comment><USER34> Is it actually backwards compatible? I don't think it is, they continually introduce breaking syntax changes.

Please somebody enlighten me

<comment><USER25> It's been backwards compatible since the 1.0 release two years ago.

<comment><USER5> Julia follows semantic versioning [1] and is now on version 1.5, which means there been five non-breaking releases introducing new features (and dozens of bugfix only patch releases). Code that worked on 1.0 also works on 1.1, 1.2, 1.3, 1.4 and 1.5 and will keep working in 1.6, etc. until such a time as a breaking 2.0 release is made. Even then breaking changes will be kept minimal and only made to enable worthwhile language features.

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

</comment></comment></comment><comment><USER10> Does Julia webstack have middle-ware like authenticators etc etc?

</comment><comment><USER35> Highly disappointed that this isn't a convention for Julia Roberts fans.</comment>


I Just Published YouTube to Mp4 API on RapidAPI. Check It Out - <AUTHOR> https://rapidapi.com/aidangig/api/youtube-to-mp4 <comment><USER2> You should probably make this a show hn if this is your work.</comment>


Ask HN: Facebook blocked us and there's nothing we can do? - <AUTHOR> We - laut.fm, a user generated radio platform running about 1300 radio stations in germany - are being blocked by facebook.
It started last Thursday. Suddenly any post or chat message containing the string "laut.fm" would be blocked with the following error message:

  You can't post this because it has a blocked link
  The content you're trying to share includes a link that our security systems detected to be unsafe:

  laut.fm

  Please remove this link to continue.

  If you think you're seeing this by mistake, please let us know.
 In addition our facebook page disappeared. It reappeared on Sunday, but any posts between last November and now where missing.
We have no further information about what might be offending facebook. Our site is pure organic user generated content. We don't do any special SEO tricks.
We and several of our users reported the blockage via the link provided in the error message to no avail. We reported an issue with our facebook page here: https://www.facebook.com/help/contact/164405897002583?rdrhc . When trying to debug the issue via the facebook debugger (https://developers.facebook.com/tools/debug/og/object?q=http%3A%2F%2Flaut.fm) one gets the error message "Failed to get composer template data.". Using a link shortener to post laut.fm links won't work either. I worked through the points on this list: http://stackoverflow.com/questions/13185406/facebook-wont-share-a-link-to-my-site  without success.
The most frustrating part is not even being blocked, but being left in the dark about the reasons.
We are out of ideas. I use this HN post as a last resort. Any help or hint on how to proceed would be highly appreciated.
Niko. <comment><USER2> I am the engineer at Facebook responsible for this mistake - my apologies, and I've already fixed it. The domain was blocked due to a false positive on one of our automated classifiers used to fight spam. While we strive to have 0 false positives, some do happen. We are investigating how this happened in the first place and will be adjusting the classifier accordingly.

<comment><AUTHOR> Thank you for your honest response. Mistakes happen all the time.

The thing that concerned us most is that as a user of Facebook we had the impression that all efforts of reporting the issue where unheard. There was literally no feedback what so ever. I totally get that Facebook can't respond individually to error reports, it's just got too many users for that. None the less we felt really helpless in that situation.

I would never have imagined anyone of Facebook would ever answer this HN post. So again: Kudos for this statement and thanks for resolving this issue.

Niko.

</comment></comment><comment><USER3> I'm not familiar with this aspect of Facebook, but it looks as though they do provide a reason in the message, though: "...includes a link that our security systems detected to be unsafe." unless this is just their catch-all phrasing for links that they don't like for some reason. Have you looked into why they may think your site is unsafe? Is your user generated content properly sanitized? Are other *.fm links working? How are you hosting (maybe the IP range is banned by some other malicious activity)?

<comment><AUTHOR> The IP range is only shared with our other services as laut.de and laut.tv which can be shared just fine. Links to other FM domains work, too. I'm pretty sure our content is sanitized properly.

</comment></comment><comment><AUTHOR> BTW: I just posted the link to this HN post on Facebook. This worked. However, if anybody else tries to share my Facebook-post it get's blocked, because the excerpt contains the string "laut.fm". Hilarious.

</comment><comment><USER4> That total lack of accountability really, really sucks. If I'm a domain registrar and my DNS servers go down, I'm liable for damages. Same if I am a hoster. Or, to stay in the meatspace, when I am a railway/flight operator, I'm liable by law for delays.

Yet, if Facebook or Google decide to block, downrank etc. my business, I have _no legal options_ at all, I don't even have any transparency. Everyone is at the mercy of the Cloud Gods. That has to change.

<comment><USER5> It does suck, but on the other hand spam is rampant and fighting it from overrunning your site necessarily means there will be some gray areas and false positives.

<comment><AUTHOR> I agree 100%. I know they at least have to try to reduce spam. I only wish anybody would react on our error reports.

</comment></comment></comment><comment><AUTHOR> Surprisingly links to laut.fm can again be posted on Facebook. Less surprisingly Facebook did not tell us why that happenend.

<comment><USER6> [https://news.ycombinator.com/item?id=7807315](https://news.ycombinator.com/item?id=7807315)

</comment></comment><comment><USER7> my site Facebook.com/keepitessential is also blocked. What did you do to fix that? I get "The content you're trying to share includes a link that our security systems detected to be unsafe" when I try to share it.</comment>


Show HN: Behind the Make – Interviews with makers about their side projects - <AUTHOR> https://www.behindthemake.com <comment><AUTHOR> The overall goal of Behind the Make is to give people an inside look at how makers work through the concept to launch process of their latest projects.

I launched the website on March 1st and so far have 7 interviews online and finishing up another 10.

My hope is that I'll be able to release 3-5 new interviews per week.</comment>


Lack of Jobs' hand in Lion led to problems - <AUTHOR> http://theorangeview.net/2011/08/lack-of-jobs-hand-in-lion-led-to-problems/ <comment><USER2> I doubt this is the case. I like Lion a lot, moreso than the Leopard incarnations. But it _is_ clearly a compromise filled release, but merely because the move to a touch UX desktop is too much to do in one jump.</comment>


Free Idea: Calcul.at/or (Giving Away My App/Startup Ideas) - <AUTHOR> http://eurekaput.com/free-idea-calculator-a-simple-natural-languag I just started posting my ideas... feedback is always appreciated. Hopefully this community of hackers will find inspiration in something I post and make it happen.<p>(I'm a YC funded startup founder with a ton of ideas and little time for side projects... so rather than file ideas way in notebooks... I'm posting them online and giving them away. Some are small app ideas, some full on "startup" ideas and some fall somewhere else in the creative landscape. No need to steal these ideas, I'm giving you permission to take them. Good luck!) <comment><USER2> I'm not sure I'm a huge fan of this particular app idea, but I'm really impressed by your willingness to give your ideas away, complete with logos and domain names (assuming a prototype is built). I tend to hold on to ideas too tightly in case I want to do them down the road. You've given me something to think about :)

<comment><AUTHOR> Valid opinion on this idea... by far not my best. But a place to start. I'm finding the whole process quite therapeutic. Maybe along the same lines of monks who make sand mandalas.

Will have to post some of my best / favorite ideas as a real challenge.

</comment></comment><comment><USER3> This app would be ridiculously easy to build if Wolfram Alpha allowed people to use their API without donating some organs. Essentially, just perform the calculations with the Wolfram Alpha API and keep history on "calcul.at"'s server side.

Problem is that WA would probably never let you use their API like that since it competes with Mathematica.

</comment><comment><USER4> Computations generated from large datasets to answer user-submitted queries interpreted via natural language processing techniques displayed in a helpful and clear way? Try <http://WolframAlpha.com>. Mobile phone support? Check out their web or native iPhone and iPad apps.

</comment><comment><USER5> A comment to the above site, by 'tlianza', mentioned <http://instacalc.com> which I found to be pretty impressive.

I didn't know it existed but am pretty sure I'll be using it.

<comment><USER6> Hey, thanks for the mention! I developed instacalc a while back and am planning on doing some updates. Feedback is always welcome (firstname.lastname@example.com).

<comment><USER7> Do you know the application qalculate? It's fantastic, but X11 only. However it's by far the most feature complete calculator I ever saw.

</comment></comment></comment><comment><USER8> relevant - Soulver <http://www.acqualia.com/soulver/>

<comment><USER9> Yes, this is a really great app. Based on GNU bc, too. The iPad version is exactly what I have wanted for doing basic math on the device.

</comment></comment><comment><USER10> Google Calculator and Wolfram Alpha are good enough for me.

</comment><comment><USER11> Is there a drop-in open source library that basically does Google-like calculations, including conversions? It's one of those things that Google does so well I don't really feel compelled to do myself, but really feel like I should have a tool for because it's not something you _need_ a massive server farm for.

<comment><USER12> I'm not sure if it's open source, but there's a command-line tool that came with my Mac that may also be on your machine to do unit conversions. It's called "units". Even if you don't want to call it directly, you may be able to use the conversion table files that are stored somewhere for it to use. As for calculations, if they are basic, interpreting the calculation as Ruby or Python code might work, though it risks the user entering something more dangerous that might need to be checked for.</comment></comment>


Ask HN: How do I get potential customers to signup on my holding page? - <AUTHOR>

We have recently released a basic holding page for our new product (www.imagexyapp.com) that allows users to signup to be notified when we release. What are the best ways for us to get attention that will bring in users that will sign up?
We have been trying the usual route of: - Social Media - Emailing existing clients/friends - Blogging about it on personal blogs and as guest authors - Sending out press releases
Please share any stories that have worked for you in the past, or any ideas you may have. <comment><AUTHOR> Clickable link: <http://www.imagexyapp.com></comment>


WMII: The Hacker's Window Manager - <AUTHOR> http://www.suckless.org/wiki/wmii/about

<comment><USER2> Uh, I actually prefer its lighter cousin, DWM: <http://www.suckless.org/wiki/dwm>

It's more productive and fits my needs better with a master/minor stack.

<comment><AUTHOR> I've been using wmii for about 6 months and I love it. I'll look into DWM though.</comment></comment>


Show HN: Flix for Kids - <AUTHOR> https://flixforkids.org <comment><USER2> It's a nice idea. A couple of bits of feedback (as both a Netflix user and parent of a 3 year old):

* The value is buried on the landing page. Instead of the empty "The Netflix viewer every watchful parent should own." consider writing something like "Limit what your kids can watch on Netflix and how long they can watch it".

* Will it work in the UK?

* Any plans to release a version for Amazon Fire Stick?

<comment><AUTHOR> Thanks for the feedback! Yes it will work in the UK and anywhere Netflix is available for that matter.

I am going to look into alternative platforms in the near future.</comment></comment>


Marriage Is Not a '24/7 Sleepover Party' - <AUTHOR> http://www.theatlantic.com/sexes/archive/2013/01/marriage-is-not-a-24-7-sleepover-party/272684/

<comment><USER2> This article is one of the best articles I read about marriage. It pointed out the bad side of marriage: "Anyone who's been in a marriage or observed one closely knows that these relationships can go through long periods of financial strain, sexual frustration, lethargy, and loneliness." But it also pointed out some of most valuable advantages of marriage :" It promises that marriage will make two people kinder, more patient, more forgiving, more creative, more selfless"

</comment><comment><USER3> > Studies say that couples experience a happiness spike in their first year or > two of marriage. But that euphoria is fleeting: A couple's happiness returns > to its normal, pre-marital level in the years that follow.

I wonder if they control for couples who have kids versus those who don't.

<comment><USER4> Meh, its pretty accurate with me. First couple of years are the "love" emotion and it wears off. Then it's hard work and effort to keep the passion going.

However the advantages to a marriage are financial (2 providers vs 1), emotional (if I'm down or vice versa, she's got my back), sexual (no more bar hopping looking for sex), disease preventative (if we're both faithful, I don't have to worry about STDs at all, except for possibilities in hospitals), skills (she has one set of skills, I another, combined we compensate for weaknesses of the other. It hurts when we're both bad at something).

Many advantages, MARRIAGE though... idk... it made no difference to us when we got married. We knew that splitting up or divorce was equal in our eyes, the relationship was too important. Marriage gives us also legal benefits, that's all we really cared about.</comment></comment>


High Availability Principle : Concurrency Control - <AUTHOR> http://saasinterrupted.com/2010/02/05/high-availability-principle-concurrency-control/

<comment><USER2> _The 101st request should not be allowed to negatively impact the experience of the other 100 users._

What about the 300th request? I guess it's a matter of opinion, but is it better to provide a mediocre (or worse) quality experience to all 300 users, or to provide a good quality experience to 1/3 of the users and deny the other 2/3 requests?

<comment><USER3> It would largely depend on how gracefully you degrade your service to those other 200 users. Take any game server with the concept of queues. They could (depending on the game, I know this isn't universal) take in more players than they allow at a time, but the quality would drop significantly. Instead, they give you a number, and say "You are number X in line. Please wait". While it isn't great, and is very frustrating for players, it is a decent solution.

On the other hand, you have Monopoly Street View, which launched with a massively higher number of players than they expected. The end result was a game that was playable for a very, very small group of people, and no one else even knew what was going on.

In general, you need to be able to balance the two. There should be a point where you have an absolute cutoff, no more users/requests beyond that, but you should also have a sliding scale. Of course a server only processing one request at a time will be faster, but you need to be able to degrade somewhat, while still providing good service.

</comment></comment><comment><USER4> Pardon my ignorance in this matter, but hasn't commoditized, scalable hosting (such as Amazon EC2) largely mitigated the issue of service degradation?

<comment><USER5> Only if every part of your system is perfectly horizontally scalable. There are very frequently some singleton aspects of a system, perhaps the most common example being a single central data store with a fan out of web servers. The web servers scale by adding more, but it's an architectural change to add a second DB.

<comment><AUTHOR> Exactly. There is always a "deployed system limit" even in horizontally scaling DB layers as deployed with sharding etc.</comment></comment></comment>


Reddit says, "please stop referring to reddit as 'small'". - <AUTHOR> http://i.imgur.com/jiHka.png

<comment><USER2> This also shows that reddit's size has doubled in the past year.

<comment><USER3> And without any visible degradation in the quality of the stories or the comments, nor any scaling issues with downtime. Good job for the reddit folks :-)

<comment><USER4> I'm sure many people would disagree on this point. There are some subreddits that are still very good, but the quality of the submissions and ensuing discussions has dropped significantly over the last couple of years, IMO.

Which is why now I procrastinate mostly here, instead of on reddit ;)

</comment></comment></comment><comment><USER5> Perhaps they mean small as a business - I don't recall Digg begging it's readers for handouts?</comment>


Getting rid of Open With duplicates in OS X - <AUTHOR> http://www.leancrew.com/all-this/2013/02/getting-rid-of-open-with-duplicates/ <comment><USER2> Great tip. Thanks for sharing!</comment>


FCC to halt rule that protects your private data from security breaches - <AUTHOR> https://arstechnica.com/tech-policy/2017/02/isps-wont-have-to-follow-new-rule-that-protects-your-data-from-theft/ <comment><USER2> The rule in question was just stuck in there _one week_ before Trump was elected, so the Obama administration can't have thought it that necessary.</comment>


A Perspective on Electric Vehicles - <AUTHOR> http://www.nov79.com/elvp.html <comment><USER2> Worthy comparison of efficiency and energy loss, but zero mention of the negative externalities of either...

</comment><comment><USER3> This site looks like the work of a quack and should not be taken seriously here.</comment>


Steps to install tmux in Cygwin - <AUTHOR> http://java.ociweb.com/mark/programming/tmuxInCygwin.html <comment><USER2> I would suggest installing Vagrant instead. ([http://www.vagrantup.com/](http://www.vagrantup.com/))

For example:

Start your new Ubuntu machine...

$ vagrant init precise32 [http://files.vagrantup.com/precise32.box](http://files.vagrantup.com/precise32.box)

$ vagrant up

SSH in..

$ vagrant ssh

And install tmux

$ sudo apt-get install tmux

*note: these commands are off the top of my head, please read the getting started guide for proper instructions.

<comment><USER3> With the current state of virtualization (vagrant/virtualbox for example), I have to wonder why anyone would choose cygwin. Honest question.

<comment><USER4> It's been a while since I used Windows so I can't really comment on the current state of Cygwin but the one thing that I still recommend Cygwin for is to use the X server if you want to log on to a *nix box and run something graphical.

<comment><USER5> I appreciate people doing work like this. I've worked in Windows-only environments and used cygwin and some window manager (such as bblite) for my workflow. Good to know if I were still relying on that crutch that I could get tmux working.

The supplied hardware at these gigs didn't really have the spec for spinning up VMs - this also spared me from fiddly network and other shared resource setup.

I even had a "portable" cygwin install on a USB stick.

</comment></comment></comment></comment><comment><USER6> Well, I just installed this. I always assumed tmux wasn't compatible with Cygwin, but I guess it is.

Note that you can skip steps 2 and 3 if you install libevent-devel and libncurses-devel in step 1. The Cygwin provided versions of these packages are good enough (in fact, libevent is the same version.) Also, I didn't get any warnings when running autogen.sh, but I have all the available versions of autoconf and automake installed, so that might be why.

<comment><USER7> You were right until very recently. If I recall correctly, tmux used to send file descriptors over sockets, something which isn't supported by cygwin. Pretty recently someone made a patch to tmux that allowed it to work without the unsupported behaviour.

<comment><USER6> I see. It would have been nice to see the problem fixed on the Cygwin side, but either way, it's great to be able to use tmux on Windows. I missed it.

</comment></comment></comment><comment><USER8> Weird coincidence: I found this yesterday and spent the afternoon compiling it up on my work machine, where I'm forced to use Cygwin for lack of anything better. Open up HN this morning and it's on the front page!

Anyway, these steps worked fine for me and I didn't even get any complaints at the autogen stage. It took about 40 minutes to get everything compiled and installed, which I didn't think was too bad on my ancient work machine.

<comment><USER9> Thanks for the "it worked for me," makes me more willing to give it a shot.

</comment></comment><comment><USER10> Wow! I didn't know tmux works on Cygwin. Last I checked there was an issue due to Cygwin not supporting proper file descriptors.

Apparently tmux has worked under Cygwin for some time now - since July at least. The actual patch appears to originate here, and is a neat little read: [http://sourceforge.net/mailarchive/message.php?msg_id=308508...](http://sourceforge.net/mailarchive/message.php?msg_id=30850840)

</comment><comment><USER11> While this comment may be a bit out of place, I thought I'd throw it in.

For any OSX users here, iTerm 2 has fantastic tmux integration. Simply launch tmux with the -CC flag (tmux -CC). iTerm 2 will open a new window for your tmux session. Tabs that are opened, split, etc. are created as tmux windows / panes and can be quickly restored upon resuming a tmux session.

</comment><comment><USER12> Why compile the first two from source? They are available in the package manager.

</comment><comment><USER13> And people wonder why Linux never became mainstream for consumers.

<comment><USER14> But cygwin isn't linux, and on 99% of actual linux distributions you will never have to compile tmux from source. A better statement would be "And people wonder why Windows never became mainstream for developers."

Steps to install cygwin on actual linux? "(package manager) (install) tmux". And on OS X? Install brew by copy and pasting a command into terminal, then "brew install tmux". Even if you're an average consumer you could complete both of those steps without a problem. (Then again, why would the average consumer want tmux?) Windows/cygwin is the problem here, not linux.

<comment><USER15> If it were on the default package list if would just be apt-cyg install tmux (if you have apt-cyg installed)</comment></comment></comment>


Google Executive Emerges as Key Figure in Revolt - <AUTHOR> http://online.wsj.com/article/SB10001424052748703989504576127621712695188.html

<comment><USER2> Mr. Ghonim actions are both brave and impressive. His connection to Google seems mostly coincidental though.

The fact that Mr. Ghonim and eight of his friends were arrested for their online statements should scare us all.

<comment><USER3> Wael Ghonim Scheduled Release Monday:

[http://online.wsj.com/article/SB1000142405274870398950457612...](http://online.wsj.com/article/SB10001424052748703989504576127621712695188.html?mod=e2tw)

</comment></comment><comment><USER4> A Feather in Google's Hat! Maybe Google should honour him in some way.

<comment><USER5> Imagine when the next time around Google couldn't find a hero. Perhaps Microsoft will? There will be an endless race to finding a hero for the revolutions.

Bad idea all around, a slippery-slope no less.

<comment><USER5> Down vote with qualification. I spent time writing my thoughts, you spent your time downvoting with a click?

</comment></comment></comment><comment><USER6> Exactly the kind of person you want running a tech company.

</comment><comment><USER7> How does 'do no evil' reconcile with 'do tremendous good'?

</comment><comment><USER3> Wael Ghonim just became notable enough for Wikipedia: <http://en.wikipedia.org/wiki/Wael_Ghonim>

</comment><comment><USER8> about as 'key' as twitter I'm guessing...

<comment><USER9> Yeah, I wonder how much the online element of these revolutions is overblown by the western media. Tunisia is credited to WikiLeaks, Iran was "the Twitter revolution", and this is being credited to facebook. I'd love to know how central a role they're actually playing, or if it's just something for the media to latch on to.

<comment><USER10> I keep seeing conflicting information about this, but my impression is that the rise of independent television (Al Jazeera) has had the deeper impact so far.

Edit: does anyone here know whether Al Jazeera has typically been censored by states in the region? I mean, of course, before the recent revolts. If not, why not? It seems obvious that a population with random access to independent news media is highly undesirable if you're their dictator.

<comment><USER11> "Yes, we may have helped Tunisia, Egypt. But let us not forget the elephant in the room: Al Jazeera + sat dishes" - <http://mobile.twitter.com/wikileaks/status/31448923629420544>

<comment><USER10> I can't help but note the underhanded self-praise in this statement. It's quite typical, unfortunately.</comment></comment></comment></comment></comment>


Epubjs: a browser-based ePub reader implemented in JavaScript - <AUTHOR> http://blog.threepress.org/2009/02/09/introducing-epubjs/ <comment><USER2> The reading experience is very smooth. Once mobile devices will be supported (I tried it on my iPhone despite the supported browsers list not mentioning Mobile Safari, but it's not usable there), this might be a viable alternative to native eBook software.

Great job.

</comment><comment><USER3> She refs two newer ones:

rePublish (LGPL3): <http://github.com/blaine/rePublish>

Monocle (MIT): <http://github.com/joseph/Monocle>

I liked Monocle's looks a little better.

</comment><comment><USER4> 16 months old and and she does not plan on updating it. She even links to a couple more advanced JS epub readers in a recent comment.</comment>


How to tell if my laptop was tampered with in China? - <AUTHOR>

I am travelling in China with a laptop which I mostly wiped clean for the trip (no personal information, no saved passwords, different ssh keys than I normally use).  On returning to my room today I found it wouldn't start up, responding that it could not find the boot device (an SSD on SATA/0).
I've had no problems with the SSD before this.
Bizarrely, unplugging the power supply brought it back.
I don't have my toolkit with me so taking it apart is not optimal, am wondering if there's any way to tell (or even hint at) if it was compromised.
While it will be annoying I can avoid logging into email if necessary as I'm only here for a few more days.
I have ubuntu 10.10 installed as well as Windows 7, the laptop is a Lenovo x61. <comment><USER2> You are too paranoid.</comment>


Onavo VPN app sends all traffic data to Facebook - <AUTHOR> https://www.wsj.com/articles/facebooks-onavo-gives-social-media-firm-inside-peek-at-rivals-users-1502622003?ref=wsj <comment><USER2> Anyone got a non-paywalled link?

<comment><USER3> Elsewhere in Murdoch's media empire, [http://www.foxbusiness.com/features/2017/08/13/facebooks- ona...](http://www.foxbusiness.com/features/2017/08/13/facebooks-onavo-gives- social-media-firm-inside-peek-at-rivals-users.html)</comment></comment>