kenOfYugen

The Nature article:

http://www.nature.com/nature/journal/vaop/ncurrent/full/natu...

No I am not comfortable with C++ code. I was under the impression that JS along with QML was a viable option, guess I was mistaken.

I have never used Qt, and I feel like I have missed out. What concise sources would be recommended for someone with a Web development background, in order to start with Qt?

That's my plan as well. Glad there are more fans of the non retina 13" ;)

MacBook Pro 13", Early 2011, 2.3 GHz i5, 4 GB, 120 GB Samsung SSD + 320 GB stock Hitachi HDD, OS X El Capitan

Mithril is really nice, I've been following its progress since the beginning. If I had to use a framework, Mithril would be my first choice.

lichess.org is a very busy application built around Mithril.

Out of curiosity, what tools are you referring to that are nicer on ES6 and not applicable to LS? Could you give examples?

> Avoid CoffeeScript. Most of its better features are now in ES6, a standard.

This argument against CoffeeScript isn't very objective. One of CoffeeScript's best features is the minimalistic and expressive syntax.

"CoffeeScript (#6) appears dramatically more expressive than JavaScript (#51), in fact among the best of all languages."[1]

"CoffeeScript is #1 for consistency, with an IQR spread of only 23 LOC/commit compared to even #4 Clojure at 51 LOC/commit. By the time we’ve gotten to #8 Groovy, we’ve dropped to an IQR of 68 LOC/commit. In other words, CoffeeScript is incredibly consistent across domains and developers in its expressiveness."[1]

Using the author's train of thought I could state: "Avoid Bluebird[2]. Most of its better features are now in ES6 promises, a standard."

Yes promises are in the ES6 standard, but that's not the best feature of bluebird. There were and are many promise based libraries, but bluebird was built for unmatched performance. One will use it if performance matters.

Even today it's faster than the native implementations of promises [3].

> Tooling (such as CoffeeLint) is very weak.

Maybe because, as it turns out, in CoffeeScript you don't need a lot of tooling. Why would that be a bad thing?

> Electron is the foundation of the great Atom editor and can be used to make your own applications.

Atom is written in CoffeeScript [4].

[1] http://redmonk.com/dberkholz/2013/03/25/programming-language...

[2] https://github.com/petkaantonov/bluebird

[3] http://programmers.stackexchange.com/questions/278778/why-ar...

[4] https://github.com/atom/atom

You should check out runtime.js [1] if you haven't. Instead of duktape it uses v8. I'd like to see an equivalent project using spider monkey so that C/C++ code could be compiled into efficient JS. Check out this speech if you haven't already: The Birth & Death of JavaScript [2]

[1] https://github.com/runtimejs/runtime [2] https://www.destroyallsoftware.com/talks/the-birth-and-death...

Great news! Node.js could greatly benefit from more reimplementations of its native modules. I had implemented the `fs.readdir` module in C and saw some good performance gains (it was a hackish experiment I did some time ago and can't remember numbers).

The `http` module is said to be outperformed by `eshttp` [1] by a factor of 2 times, which is written in pure JavaScript.

There is also `node-lwan` [2], an experiment in using `lwan` [3] in place of the built in `http` module. Since its the most performant web server in JSON serialization, according to techempower.com benchmarks [4], performance gains are to be expected.

[1] https://github.com/iefserge/eshttp [2] https://github.com/raadad/node-lwan [3] http://lwan.ws/ [4] https://www.techempower.com/benchmarks/#section=data-r12&hw=...

There is this guy who has made some similar engine prototypes in this field of efficient opposed piston engines.

PatOP: Single-Crankshaft Opposed-Piston Engine

http://www.pattakon.com/pattakonPatOP.htm

OPRE: Opposed piston Pulling Rod Engine

http://www.pattakon.com/pattakonOPRE.htm

  > A 500cc two stroke can easily make some 80 Nt*m (8 Kp*m) torque.
  > At 6000 rpm this torque makes some 50 KW (70 PS).
  > 50 KW from 20 Kp means 0.4 Kp per KW.
  > And 0.4 Kp/KW with direct injection Diesel efficiency sounds interesting, especially for an engine with such a low cost."

I enjoy Literate CoffeeScript and that's where I picked up the concept of Literate coding.

I believe that literate style of code writing has many benefits in any language.

Basically mix markdown with the codebase and export the documentation from the same file.

For a very well executed and interactive example check out

http://dave.kinkead.com.au/modelling-the-boundary-problem/

The cost of transpiling es2015 isn't very visible here, because the "vanilla es6 TodoMVC" example used [1] doesn't rely heavily on ES6 only features, such as generator functions etc., that aren't just sugar on top of ES5. Such features are expected to decrease the performance of the generated code significantly and should be taken into account when a transpilation step is involved.

[1] https://github.com/tastejs/todomvc/tree/master/examples/vani...

In previous work [1] we followed the Linux kernel documentation [2] and the guidelines published by IBM ITSO [3].

[1] http://link.springer.com/article/10.1007/s00607-014-0394-9

[2] http://www.cyberciti.biz/files/linux-kernel/Documentation/ne...

[3] https://lenovopress.com/redp4285.pdf

Mindblown! So much concentrated information and so nicely presented! Would like to see more low-level stuff that makes sense.

flowtype.org

  > Standard c99

If you have to write C, why not go with ANSI C/C89 for compatibility/portability reasons?

I like Douglas Crockford's "Class Free OOP" approach for managing dependencies and composing functions:

  function constructor(spec) {
    let {member} = spec,
    {other}  = other_constructor(spec),
    method   = function () {
          // accesses member, other, method, spec
    };

    return Object.freeze({
      method,
      other
    });
  }

but prefer to use an immutable data structure instead of Object.freeze().

All application state can be stored in a single "Atom" (i.e immutable data) and all message passing can be achieved through CSP channels.

When dealing with the DOM, 'incremental-dom' is a nice option.

Of course, separating pure functions from side-effects inducing code is key to maintaining control.

This is my approach when going "framework-less".

A few more classic and esoteric languages are available in https://repl.it/

React has shifted the questions asked by newbies, from which framework to choose, to what tooling to choose to complete the framework. Essentially it's a framework in library disguise.

It's used more as a simplifying term for a family of related technologies, rather than React the library itself.

For experienced coders this doesn't matter too much. More toys to play with. Newbies seem to be having a hard time picking up all those buzz-word ridden notions of the available tooling.

Not everyone can have a deep computer programming background, so they have to be confused and then get it wrong, in order to learn.

It's not React's fault, it can't solve everything. It is what it is, the problem is irrational people, trying to make a front-end messiah out of it.

OK, I stand corrected. Appreciate it that you took the time to write this explanation.

You are welcome ;) Finding good C resources is rather hard...

One can use the same Go style concurrency in C with libmill [1].

Another interesting choice for concurrency would be lthread [2].

  What’s special about lthread is that it allows you to

  make blocking calls and expensive computations, blocking
 
  IO inside a coroutine, providing you with the advantages 
  
  of coroutines and pthreads. 

[1] http://libmill.org/

[2] https://github.com/halayli/lthread

Yes, I know about legit re-submissions, but as you said this is not the case.

And I totally regret pointing it out since my karma has suffered great damage...

Still, one can take down all the new stories if they want, to promote their content for example, by using such methods.

Wish I could just delete my parent post but unfortunately I can't...

There were no constructive comments when I posted my message. I was not sending anyone anywhere, I was notifying that there is a duplicate with the same URL. Personally, every time I submit a new recent story I make sure it hasn't been submitted before.

Anyways, I think this case with URLs not being completely the same but directing to the same page should be pointed out and discussed.

My submission linked to:

https://medium.com/@networksecurity/oleoutlook-bypass-almost...

While this submission links to:

https://medium.com/@networksecurity/oleoutlook-bypass-almost...

Whereas just: https://medium.com/@networksecurity/oleoutlook-bypass-almost...

would suffice.

Doesn't this leave room for multiple "spammy" posts?

Duplicate:

https://news.ycombinator.com/item?id=10790734

Previous discussion from 3 months ago:

https://news.ycombinator.com/item?id=10257305

Thanks! I'll give it a try then and maybe Nix too!

Anybody using Alpine for a minimal Desktop OS? How does it compare to something like Arch?

Maybe it's time browsers improve the decoding performance of HTML5 videos. In my experience Wirth's law is in effect when it comes to browsers.