skysight-inc/HackerNews huggingface dataset:
Components are easy. Just write a function...

Until you want to automatically unregister event handlers when the component is removed

Until you want to compose them and select child and parent components without traversing the DOM

Until you want to pass options to the components in various ways, and have default values for them

Until you want to store component state and re-render part of the component whenever something in the state changes (since storing state in the DOM and reading it from there is bad)

Until you want to load javascript files on demand to construct and manage components instead of loading everything in one huge js file up front for a big website

Until you want to have a unified CSS convention so you can style all these components

That's when you need a well tested framework.
You can also use something like TinyMetrics [http://www.tinymetrics.in] where you can get this kinds of lists + a bunch of other metrics and insights.
I'm not really fighting you on the merits of frameworks (which should be obvious to everyone), but are you implying that implementing a design pattern is equivalent to building a framework?
If you seen reefs at their pristine condition and see reef at most of the places nowadays, you'd be more indifferent to these news.

I saw a live reef several years back in Egypt and it was a astonishing, beautiful and alive. After this I've been few other places and while there were some fish, it was nothing like that. Everything I saw is like the 'destroyed' picture in the article. I think such damages don't do much impact on these reefs as they are effectively dead anyway.
Good news for Ericom?
Because you are dealing with passwords, I'd really recommend forcing HTTPS, which unfortunately doesn't seem to be available at all.

Other than that, I like it!
... which reminds me about a story of a suburb in the seventies.

When Grorud (IIRC) in Oslo was built, the planners wanted tall buildings for density. An architect whose name momentarily escapes me came up with a counterproposal, namely copying the houses you see here (the most popular in the country at the time), and adding three large parks. http://www.agderposten.no/polopoly_fs/1.1060255.1397321665!/...

The counterproposal had the same density, despite the three additional parks. Guess what was built though.
Why would it be more work? You've already learned what work and what don't work in the first version. You can reuse a lot of the original code. A lot of the experiment and exploratory code can be thrown out. Ending up with a Java version can be a good thing.
Writing a Slack integration with sipgate.io telephony API
I went down a similar path a few years ago when starting a new project. Instead of learning a new framework I wrote my own. It took less time overall, since the logic wasn't especially hard to write, and it was easier to debug - at first. Everything changed as soon as another developer, then two, then three, started working on it with me. They were not happy about learning how to use my custom MVC framework.

Perhaps the most valuable thing about frameworks is that they are common languages. They make it easier for developers to dive into a new code base and quickly understand what's going on. It's not entirely about functionality. I think this is partly why framework usage seems to be so trend and style driven; everyone wants to be using what everyone else is using.
Can't blame the tools for a lack of decent developers any more than you can blame a spell checker for illiteracy.
Mass surveillance by the security services in both the USA and UK took a long time to revealed to the public. I'd count that as a 'large-scale conspiracy'.
You should think big. The cloud is the future of GUIs.
20 Years Ago Today, Sun Almost Bought Apple for $4B
...as opposed to Cisco quality? Interesting position.
This premise has always been the first thought in my mind when hearing of a conspiracy. Cool to see it modeled in historical context.
Not at all but what is the end goal of this if we consider that the code base will increase in size? You'd likely start adding more and more things to it to make it easier to work with and eventually you've unintentionally rolled your own framework.

React could also still be implemented as part of the author's view because they haven't covered any of the problems with large cascading data updates. So there's literally no argument against React in this post. It's basically just a post about how to implement a design pattern in a language, React doesn't even need to be mentioned. I might even call it click bait.
I would cede karma points to comments like this! It reminds me of my all-time HN favorite: https://news.ycombinator.com/item?id=1611792
Somehow I don't see him using Java, but if he said so, then ok.
I've done quite a bit of work with CBOR. I took a quick look over the Message Pack spec and found it a bit wanting. The CBOR encoding is more consistent and it allows one to easily define extensions (up to 2^64 worth http://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml). One defined extension allows you to define references, which I found useful in encoding Lua tables.
True; us, the Web community (which also built the frameworks) as a whole, is to blame.
Changing a fundamentally well-defined term (main thread, i.e. the one on which main() is called which is running the core event loop for the application process) to be an incorrect opposite is rather fundamental when one is explaining an iOS best practice.
A longer summary: the maximum height of a siphon pumping water, at sea level, predicted by barometric pressure is about 10m.

But the tensile strength of water is nonzero (a surprise to me) and that is enough to allow much higher siphons if you first remove dissolved gases from the water.

The paper speculates that several hundred metres may be possible, perhaps even more. The paper also describes an actual experiment where they showed that a 15 metre high siphon works in practice.
Before this gets overly sensationalist, see the follow up tweet: https://twitter.com/krakenfx/status/692241981309894661
Related: the meteor people announced they'll be working on this problem. http://info.meteor.com/blog/reactive-graphql
Skype Translator – Translate calls in 7 languages and messages in over 50
Our economic systems in the West may be far from ideal, and certainly create huge imbalances between the richest and the poorest that we would do well to address for many reasons. A significant part of that imbalance comes from our company structures, where the workers creating the value often receive relatively little compensation, while founders, investors and the most senior staff receive most of the benefit.

That said, I don't think your argument that no-one is worth a huge amount of money is inherently a strong one. My favourite example of this is JK Rowling, who is arguably the most successful author in history and reportedly worth around a billion dollars today. That money was earned primarily from the success of the Harry Potter books she wrote, which have sold almost half a billion copies worldwide. That's a lot of happiness she's created for a lot of people, and personally I don't begrudge her being heavily rewarded for doing more good than most of us ever will in our lifetimes.

The position is not as clear cut in the case of Paul Allen, since he didn't almost single-handedly write the software that generated the vast amount of value Microsoft has produced in the world over the years, and there is a much stronger element of the founder/investor/senior vs. employee argument I mentioned before in his case. But given how much value Microsoft has generated over the years, if you're going to criticise Allen's wealth I think you need more than just a blunt "no-one deserves to be that rich" argument to be convincing.
UK - Europe

This tells a lot. :)
This this this. Why is the best comment at the bottom.
The problem with compression is, it's everywhere.

Sending a jpeg, over compressed http(s), throught a compressed and encrypted VPN is too much compression. Then the client may save the jpeg to a local compressed NTFS cache... This is just wasted performance, plus compressors are a common place for bugs, so this is also a security issue.

Just stop adding compression to everything and think about it first, and then Mobile phones and modem lines may very well be an exception.
Sun had an amazing way of being ahead of themselves and then not quite following thru.

Apple was a steal in 95 and the network is the computer. All very obvious today.

Yet the world is reigned by other giants.
React is just a library. It is the ideas behind it that are important:

a) building web front-ends by dividing them into components which are first-class citizens of the codebase, and can be composed, parameterized and reused, just like pure functions. [1]

b) expressing the view as a pure function of state has replaced any need to mutate the DOM manually and think about transitions ($.remove(), $.append() etc.). We need virtual-dom and diffing to be able to pull this off successfully, which makes this abstraction irreducible.

c) interspersing content-inside-code (JSX) is better than code-inside-content (template languages like Angular). [2]

The recent 'React fatigue' is due to people trying to figure out how to best manage state within this framework and causing a lot of noise in the process. And that is perfectly fine, but if you are confused by it, just use vanilla React and React's immutability helpers, keep all the state in the root node and pass everything down as props {...this.props}, and then when you get a hang of it, hop on to Redux. There is no 'one true way'; as long as your app works and you can hold it in your head, everything is fine.

[1] - http://www.jasimabasheer.com/posts/on-react.html
[2] - http://www.jasimabasheer.com/posts/evolution-of-view-templat...
EFF wants 14 years of collected mass surveillance phone records destroyed
You can include the python interpreter inside the virtualenv. It's not entirely painfree (python and any pip packages are normally dynamically linked), but it works reasonably enough, especially when deploying it on the same OS version.
if you aren't setting capabilities, changing users and limits, and docker is a packing system
For me killer features would have been -PCI pass trough, higher and better performing 3d driver, better work with hardware disks - that feature never quite worked on Windows at least. Remote/connect/management and so on - they are nice to have.

These features may have been prohibited by corporate management for some reason since ESXi have passtrough. And yeah - I view it from strong power user/developer/gaming angle, not sysadmin.
Diabetes Cure Hope After Cell Transplant Trial
imo: frameworks are materialized expectations

given that software development is mainly about managing expectations this is of huge value
You are absolutely right, but I do believe people should start learning the alphabet before trying to read a book.

React looks fine to me and at my daily job our frontend devs do some amazing job. I just wanted to learn and all I seem to find is how to learn javascript through React, and not React through Javascript.

I do agree this is a home made solution and would not work nicely with lots of devs involved. I'm talking about learning though, and we devs are usually bad teachers when we don't know how to boil it down to the essentials.

How many people do you know that only use React to draw boxes and not for the advantages it brings?
The Role of Software Testing in Healthcare
If you rewrite your app you end up with something better, in any language. It's an uncontrolled experiment, and so the headline is very likely misleading - this isn't about Python and Lua. And many of us have been majorly inconvenienced when a manager read a similar headline and declared that we would rewrite our app in language y, regardless of whether that language is appropriate to our circumstances.

Something like http://roscidus.com/blog/blog/2013/06/09/choosing-a-python-r... where the author actually considers multiple candidates and performs a controlled comparison would be far more valuable. Given that the goals sound very similar I'd be very interested to see a comparison between Lua and OCaml.
Thanks for the compliment about FLIF's progressive decoding! (FLIF author speaking here)

However, truncated FLIF files will (probably) never achieve the same quality/size ratio as dedicated lossy methods that can produce a completely different file for each quality setting.

So at the moment I still see an important use case for lossy methods. However, in the future, I can imagine that people will start to demand/expect lossless encoding, to avoid generation loss and to get the most out of their display hardware.
E.g. higher bit depths are becoming a thing, while the JPEG/WebP color space (YCbCr) is effectively less than 22 bits per pixel (roughly speaking, red and blue are only 7-bit), and chroma subsampling makes this even worse. Also what's the use of ever higher display resolutions if most of those pixels are only displaying compression artifacts or blur?
Lossy formats like JPEG/WebP/BPG/JP2/JXR are good at medium-quality, but if you use them at a near-lossless quality setting (e.g. 99 or 100 for JPEG), they often produce bigger files than lossless formats.

Meanwhile, the range of display sizes is getting larger: while in the past, we had a range from say 13" monitors to 21" monitors, now we have a range from 1.5" smart watches to huge 100" smart TVs. I do think that in order to avoid huge amounts of rescaling/transcoding, we need image/video formats that are "responsive by design", like JPEG2000 and FLIF (and progressive JPEG to some extent).
Using TweenMax with React [video]
"Europe" here refers to the continent, which the lands of the UK clearly are not a part of. It does not refer to the European Union.
Why use vmware's stack over proxmox?
How much of the 26mb JS is actually invoked at run-time?

I tested several real world web sites, like google search, github, google docs - only around 30% of javascript loaded into browser is actually invoked at run-time. Maybe in your case the usage ratio is much lower?

Would it be helpful to remove unused code with a tool like this https://github.com/avodonosov/pocl ?
Or it can not matter at all. To the kind of enterprise that is still running RHEL 6, maybe shipping a 200mb install on a CD will show them that you're a serious business.

There are use cases where 200mb of disk space matters, but for the overwhelming majority of applications, a 5% (say) increase in developer productivity would be well worth adding 200mb to the install.
Cyberlink WaveEditor 2 Crack Serial Key and Patch Download
There are some subtle bugs in this code. For example `new App.View.Hobbies(model.hobbyList)` is not going to do what you're expecting when the `Hobbies` function is explicitly returning an object.

I like the premise of the post, but I did not find the end result very convincing.
What are the practical implications of higher siphons?
There is no 'one true way';
as long as your app works and
you can hold it in your
head, everything is fine.

With all due respect, this is the major criticism of adopting React, given that it's still in active development and given that many who are looking at using it have established apps using other patterns already.
What would be really awesome (and probably insanely difficult to make) is an API which does something similar to what Google does when you define: stuff. It usually comes from a dictionary, but sometimes it has more interesting sources. I'd love to put something like that in an IRC bot.
I'm going to set that up tomorrow. I honestly wasn't sure what kind of feedback I would get, but so far most people have been excited.

If you want to send me your email I'll let you know when I've finished setting it up. Thx for the feedback! And good call!
New with Firefox 44: DevTools Challenger – Taking the Pain Out of CSS Animations
brackets overload
Slack is something i value highly right now, yet i would never have thought it took off like it did. IRC has been around for decades, bots that could post any kinds of info to a channel as well and for a user IRC is not that much harder to use than slack, but it's definitely more nerdy.
So i kind of feel sad that open stuff like IRC didn't really ever become mainstream and now we have a closed platform that at some point will belong to one of the big tech corps and people will start to move off of it again.
Or, you can make it run on old hardware, and new underpowered hardware like netbooks, Raspberry Pi, and phones.
Well, sorry for double-post, it suffices to project the variable ;-)
Show HN: Twitter-Streaming with Apache Flink
Unikernels will send us back to the DOS era – Bryan Cantrill
There is not a single Favicon visible for me on this site. Guess they are all loaded remotely or something. No idea. Chrome / Ublock Origin / Privacy Badger.
I have discovered this little gem, allowing you to do the same in pure Javascript: https://github.com/leeoniya/domvm

The equivalent would be something like

function() selected { return true }
["h2", {class: function() {if (selected()) {return "selected"}}}, "Hello"]

Not as clean, but still usable IMO
Have a look at OCaml. For simple standalone binaries it's a real sweet spot: it's powerful and safe without being complex. It has the best module system going and a mature open-source ecosystem, and in the last few years it's converged on a good package/dependency manager. There's a great series of blog posts from someone who looked at replacements for Python and ultimately moved to OCaml, summarized at http://roscidus.com/blog/blog/2014/06/06/python-to-ocaml-ret...
I used Merlin pretty extensively, yet this example had me sitting there with an open mouth, staring in awe.

The funniest thing is that in my experience Merlin just seems to work. When I think about how many hoops I need to jump through with the Clojure REPL to connect it to CIDER in Emacs, Merlin just works in the background without me having to think about it at all. Very impressive.
"frameworks are materialized expectations"

I like that. It's a nice way to put it.
At the risk of getting downvoted myself, I wonder why all of your comments are getting downvoted. Is it such a terrible opinion that it doesn't even belong on HN? A lot of people turn off syntax highlighting. It can be legitimately distracting, and it messes up tooling.
I guess this is a case of desire causing suffering.
Show HN: JavaScript Components with RactiveJS and AmpersandJS
Oracle raises questions on open-source license for Android with OpenJDK
Tally ERP 9 Release 5.3 Crack and Activation Key Free Download
How very naive.
Someone with more UI development can comment here , but i always thought progress bars where more like a signal to the user that "something is being done" , and not a representation of how much is done and how much is left.
Intelligent people are genetically predisposed to be healthier, experts find
Or you use promises/observables (with arrow functions) or generators or async functions, and they don't. 2014 called, they want their node problems back.

Basically almost none of the criticism in this whole thread is true today. The only remaining true bit is that node still relies on cooperative multitasking and one of the tasks can hog the CPU of a single worker. Which isn't very good, but still, way better than say, the good old Rails 1 request per process model.

Someone should probably do a proper benchmark to show how different numbers of workers at different CPU workloads affect a node service's response time / latency. Especially with multiple processes (cluster), I would bet the effect would be much better than what people expect it to be.
React is JavaScript.

jQuery, sure, that's probably harmful in the long run, but you have to know JavaScript to use React.

/Structuring/ an app is a different skill that takes lots of consideration, especially in a language as flexible as JavaScript.
I wrote the original article this one is based upon.

I very much enjoyed reading this one. Though I always find it more beginner friendly to start off with a framework rather than going vanilla. That goes for almost all subjects in tech. Then you can dive deeper into the material once you have a basic understanding.

Here is a link to the original article:
https://medium.com/learning-new-stuff/building-your-first-re...
I disagree. I think the boy scout rule applies but should be interpreted as follows: when you see technical debt, you should try to fix it, but when this would take too much time, at least fix it a bit. This way technical debt will be fixed eventually, but it doesn't disrupt the timeline of the current sprint/ project too much.

E.g.: suppose you are fixing a bug in some part of the application that was not written by you, for instance it could be written a while ago by a colleague who's no longer here.
And you notice that the code is written so badly that it takes you a long time to understand. What you should do is:
- write tests that verify the code behaves as expected
- fix the bug (so the tests succeed)
- refactor the code until you think the next colleague who's reading it will be able to understand it. If this is too much work to do all at once, at least fix the most urgent parts.

This is the well known 'red, green, refactor' mantra.
Thanks, somehow I missed that
> ...and even the rfc you refer to specifically states it has different goals (though, eliding specifics with pretty sad generalizations) [link to RFC7049, section 9]

You find those generalizations sad because that is the acknowledgements section!

If you start from the beginning, you only need to read three paragraphs to see that "Appendix E lists some existing binary formats and discusses how well they do or do not fit the design objectives of the Concise Binary Object Representation (CBOR)." [0]

If we look at Appendix E, [1] we find that section E.2 contains an explanation that you're likely to be more satisfied with. [2] However, before you go off and read section E.2, I strongly urge you to read the couple of paragraphs in Appendix E, first. The authors of RFCs generally tend to try hard to remove redundancy in their prose, and later sections often elide information covered in earlier sections.

[0] https://tools.ietf.org/html/rfc7049#section-1

[1] https://tools.ietf.org/html/rfc7049#appendix-E

[2] https://tools.ietf.org/html/rfc7049#appendix-E.2
All future frameworks should be designed to be easy to learn. This means removing (or at least better isolation of) complexity, but also making a nicer API and writing tutorials as an essential part of the framework. If there's anything really cumbersome to explain in the tutorials, it should be simplified.

So I recommend the author learn minimalistic libraries like Riot instead of React. Those are really lightweight and very easy to grasp. However, even the docs of Riot could still be improved. Despite its simplicity, I could have learned it in half the time if it had a better tutorial.

Essentially, this means applying findings from UI design to framework API design. Here, the user is a developer, but surprisingly many principles still hold: Principle of least surprise, make similar things look similar, make different things clearly different, and so on.
imo: frameworks are materialized experience, opinions, and testing.
I think you mean 25.5% being high? Or Am i reading it wrong?
GrapesJS