vbit

Copyright is different and enforceable - see what RIAA did to some downloaders.

Not illegal perhaps but violates the TOS

For a non-vim user - can you describe what vimdiff is please?

Why is it a dumb policy?

Is your editor publicly available?

The parser will match the specified grammar exactly, like it should. You could of course specify a grammar that is broader than the actual language you are parsing.

In spite of drivers being non AGPL, companies with 'absolutely no AGPL' policy cannot try the open source version of these DBs which puts these products behind others. I don't think AGPL provides any real benefit for the vendor. Most small organizations will want their patches (if any) to be upstreamed so they don't have the maintenance burden. Most big organizations will want commercial support anyway. All AGPL does is discourage adoption.

There are plenty of non-AGPL DBs out there doing pretty well. Here are some examples of GPL/MIT/BSD style licensed DBs: Riak, Cassandra, Redis, MySQL, PostgreSQL, ArangoDB, CouchDB.

AGPL is real show-stopper for serious adoption, IMO.

Seconded. LuaJIT FFI is just awesome. Check out the motivating examples: http://luajit.org/ext_ffi.html

BTW, does anyone have recent benchmarks comparing LuaJIT against new versions of the Javascript JITs?

I agree with you. In fact I think the reason we have to do squashes and lose fidelity is because the git model is broken.

There is not technical reason a source control tool could not offer multiple 'views' into the commit history. A high level linear view which you can zoom into to see the underlying commits and merges. Why do I have to lose the latter to see the former?

How mature are the Android and iOS ports? Would you recommend them for production use?

Python errors out if you don't specify all arguments.

    >>> def f(a):
    ...   pass
    ... 
    >>> f()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: f() takes exactly 1 argument (0 given)
    >>> 

I agree 1-based indexing isn't ideal, but in the grand scheme of things, the default nils and the method/function syntax are a constant source of mistakes and frustration for me. In Lua you have to call `obj:method()` which to pass `obj` as the first argument. If you accidentally do `obj.method()` - there is no error, but the first argument becomes `nil`.

In Python, there the call syntax is consistent and `obj` is automatically passed as the first argument for methods.

The 1-based indexing isn't particularly bothersome. It's the method vs. function determination at call site combined with default nil for unspecified arguments that really gets you.

Linux only - bummer. Not even FreeBSD.

The turbolua.org project is somewhat similar (i.e. a webserver with Lua support).

Given it is open source, couldn't Atom just re-use VSCode's intellisense?

SSHFS?

Would macros win you over?

Some discussion here:https://www.reddit.com/r/freebsd/comments/4azhmm/freebsd_a_l...

Could you highlight some of the reasons you liked it?

Javascript runtimes these days are plenty fast. You can definitely have a snappy editor and in only rare cases might need C. The issue is probably reducing the browser overhead, i.e. rendering DOM updates and the memory weight of the entire browser stack, etc.

No, I meant having one ast but multiple 'skin' languages. Eventually I think they didn't pursue it all the way.

Funny, this was one of the goals of Nim, I believe.

Any support for FreeBSD?

How do you do a linear search in a piece chain? Doesn't seem very efficient.

So here's yet another attempt at describing terra :)

Firstly, 'typed Lua' really meant the terra sub language because it looks like Lua with types.

Going back to terra, consider that 'terra' is a language that can be compiled by LLVM into machine code. So you can choose to either compile and emit object code, or compile and immediately run the generated object code. The other choice you have is to either write terra code by hand, or generate terra code from Lua code.

You say 'if typed Lua is being "generated" (i.e., it's the target) how come Lua is being used as a metaprogramming language'. Why is that not possible? Many languages have built in metaprogramming using the same language (notably lisp code can generate lisp code).

Another way to look at this is Lua is the metaprogramming and control language for generating, compiling and running Terra code.

Instead of generate LLVM code, you could instead generate 'typed Lua' using Lua as a metaprogramming language. Then the 'typed Lua' can get compiled down by LLVM into object code.

This is what http://terralang.org does.

Interesting that it took so long to reach this conclusion. I thought Linux devs stayed away from ZFS mainly due to the licensing which leads me to believe it's not quite as 'obvious' as this post mentions.

Can you give an example of 'more complex regex searching'? I thought the JS regex engine would be at par with whatever sublime uses.

See also ubjson (http://ubjson.org/) which is quite nice because it is a simple format that manages to be quite concise and extensible.

An interesting feature is support for strongly typed arrays and objects. This lets you embed binary data as-is by specifying it as an array of uint8.

Same for Lua.