jpfr

   forcing pretty much all computation no matter how trivial
   into contortions via numpy incantations so that the inner
   loops can run in native extensions

Welcome to the development of Matlab-style code. It can be pretty disheartening to see a complicated hand-crafted algorithm replaced by, say, a matrix multiplication. Try to find Matlab/numpy implementations from paper authors. This programming style is a bit difficult to get used to initially. But it will become incredibly powerful as you start thinking in algebraic operations.

Also, don't do debug runs on the full data. Implement ideas with a subset that computes fast. Then simplify the code and make it fast. Then run it on the full dataset.

If you absolutely need to combine linear algebra operations with fast imperative code, have a go at the Julia language [1] or use a C++ library like Eigen [2] or Armadillo [3].

[1] https://julialang.org/

[2] http://eigen.tuxfamily.org/index.php?title=Main_Page

[3] http://arma.sourceforge.net/

This post is not helpful for those who genuinely try to build a community in their domain. Also, a good talk compresses many days of reading and a-ha moments into one hour. It's just a lot of work to prepare a good talk.

Background: I'm one of the organizers of a machine learning meetup in my area. We (organizers) are PhD students, so building a strong and connected ML community in our surrounding is an intrinsic motivation. We decided not to affiliate ourselves with a company. Otherwise our quality control for talks would inevitably be overruled at some point.

Interesting. Do you have some pointers for more information on these efforts?

http://www.1024cores.net/home/lock-free-algorithms/queues/no...

The original implementation is a bit more involved [1]. Here, the stub entry is not considered at all during the pop.

[1] http://www.1024cores.net/home/lock-free-algorithms/queues/in...

And on mobile devices, many hardware component vendors provide custom drivers (with binary blobs) anyways. It will not be hard to convince them to support Fuchsia for new hardware releases. If they loose access to Android otherwise...

[1] https://en.wikipedia.org/wiki/Rump_kernel

If you look at the offerings of GE, Siemens, and the like, all signs point towards OPC UA as the TCP based protocol for industry that everybody agrees to use.

https://pdos.csail.mit.edu/6.828/2012/xv6.html

(The alternative is learning PDP-11 assembler and reading the original Unix v6 sources with Lion's commentary.)

I did not say all members of elite military units are psychopaths. Some are.

And after all I've seen, the concentration seems higher in those military units than in the general population. We are talking percentages here.

How ... unsurprising, given their choice of occupation.

Bits of AI history and the current state. But no current or future applications of AI in industry.

The guy who discovers the first killer application in the space will be rich and famous. Until then, most efforts will go the way of scheduling theory.

Theoretical results are nice. But 90% of effort for building applications goes into domain and project specific details. So every new client project is starting nearly from scratch.

This is a consultant project-business. Not a startup product-with-market-fitness business.

https://github.com/LuaJIT/LuaJIT/commits/v2.1

    env['f'] = myfunc

            local env = {}
            env['args'] = {...}
            setfenv(f, env)
            return f()

It's all contained in the sample pages http://matrixeditions.com/VC5.Chap2.219-221.pdf

However, even though the formula is O(1), the runtime of the algorithm might be larger.

Simply because a standard 64bit integer might be too small. And the BigNum implementation needs more time to multiply all the bits.

Leonid Kantorovich won it for applying his results in Operations Research [1] to planning the Russian economy.

John Nash won it for .. of course .. Game Theory.

[1] He proved criteria for the convergence of the Newton Method and quite a bit more. Those results are applied really everywhere nowadays.

See here: https://github.com/JuliaLang/julia

  OpenBLAS — fast, open, and maintained basic linear algebra subprograms (BLAS) library, based on Kazushige Goto's famous GotoBLAS.

  LAPACK (>= 3.5) — library of linear algebra routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems.

  MKL (optional) – OpenBLAS and LAPACK may be replaced by Intel's MKL library

I think it is great to see that a port of the Fortran code in Julia is nearly as fast as the Fortran code itself. So you can take Julia and write concise Matlab-style code (vectorized everywhere) or write imperative code (loops everywhere) and be equally fast.

Note that the graphs in the post are biased. The Fortran version uses a different algorithm for the solver.

Edit: The Matlab code is highly obfuscated. That is not good for the sake of comparison.

https://github.com/precisesimulation/julia-matlab-fortran-fe...

Cybersyn is basically the same thing. Only that it got wrapped in control theory and less in operations research (optimization theory).

[1] https://www.theguardian.com/books/2010/aug/08/red-plenty-fra...

Currently, all arrays require a malloc. Once the JIT-compiler is sufficiently smart, Julia could use stack-allocation of temporary arrays (that cannot escape the current context). Algorithms making use of temporary arrays will become faster by possibly an order of magnitude.

Julia might become competitive with C / Fortran for general purpose computing. And that is a level of speed all your other examples cannot hope to reach.

We now see the effect of this new knowledge about a previously opaque sector. Politicians and buraucrats are not as afraid any more. So banks cannot get away by having the tax-payer carry their risk.

[1] http://www.eba.europa.eu/risk-analysis-and-data/eu-wide-stre...

Elisp will not go away. So any arguments for lisp and against scheme are void in this context.

https://www.lua.org/manual/5.2/manual.html

Emacs-guile is working today. That's a first after many many years of talk and proof-of-concept stage efforts.

I hope the development will pick up speed once guile 2.2 and emacs 25.1 are out. Both projects underwent some big changes/improvements lately.

One sign of live is that bpt's improvements to guile elisp were rebased on a recentish guile-master. This branch lives in the main repository now.

http://git.savannah.gnu.org/cgit/guile.git/log/?h=wip-elisp

Also, I have seen some recent commits from emacs developers to guile. So the two projects are talking to each other.

Now, imho, the success if emacs-guile strongly depends on whether they manage to share the load across several developers. A more open development culture surely would help.

See the trade-deficit of +3 billion bounds every month? Britain is bleeding dry. And now the money won't "stay in the family".

The EU is talking survival. The UK will get indeed a bad deal. And the rest of the EU will stick together even closer. I hear "fiscal harmonization", e.g. common taxation is the new big thing.

http://cppcheck.sourceforge.net/

It all boils down to naming conventions. Dot-zero is the new beta...