jpfr

There are many many successful applications. Yes, production scheduling has proven to be "resistant" towards mathematical optimization. But many other engineering disciplines rely on it heavily.

Take for example model predictive control aka receding horizon control.

Control people have always built formal models of their systems. And now they use optimization theory where the systems don't fit the old linear quadratic controller paradigm very well.

You drive a car with traction control? Chances are that some embedded system is solving an optimization problem at kilohertz speed so you stay safe when turning on the road.

Scam-Journals are a business. https://en.wikipedia.org/wiki/Predatory_open_access_publishi...

Enough people succumb to the pressure and publish anything just to look good on the publication count metric.

Between a Greek accountant and a German one, who do you prefer?

[sarcasm off]

In todays world, Holland is tiny. It cannot make many meaningful decisions on an international level. How would Holland negotiate with the USA or Russia about trade issues? Well, they couldn't. They'd have to concede to any terms that are dictated from the outside. And like that, every European country on its own would be marginalized over the years.

Together, they at least have a chance. European countries are always debating and don't speak with a single voice yet. But at least there is a chance for survival.

   Just look at my country, Holland. Pretty much all important decisions are made by
   the EU. An example: we cannot control our own borders. We cannot decide how many
   immigrants we want to allow. The EU wants to force quotas on countries and if they
   don't accept the quotas, they want to give the countries fines.

Exactly. There are a million refugees in Europe. And you cannot just send back refugees from war zones as per international law. Somebody has to take them up. Europe has 500 million inhabitants. So there would be 0.2% refugees (i.e. "no problem") if they were properly distributed. Europe is community. Everybody profits from being a member. But every member has to carry some of the weight.

At my university (KIT in Germany [1]), they developed such a system and apply it for live-translation of lectures for international students.

Here's a demo: https://www.youtube.com/watch?v=DjXpKz0BiIU

And a publication from 2008: http://isl.anthropomatik.kit.edu/cmu-kit/861_lt2007%281%29.p...

At one point, they had an app that did live-translation. But Facebook bought the tech and took it off the market. https://en.wikipedia.org/wiki/Jibbigo

Today, they are riding the deep-learning wave to get ever better/faster recognition and translation. So huge improvements are to be expected.

[1] The professor, Alex Waibel, also has a chair at CMU.

  I know for a fact that if the Emacs developers weren't
  doing a bang up job, which they are, then I would
  immediately allocate some of my time to help.

Development is going great IMHO. However, the bug count is steadily increasing. Any time invested into emacs is well spent.

https://lars.ingebrigtsen.no/2016/05/03/emacs-bug-trends/

Exactly. This was a brilliant choice of action. And Merkel is blatantly telling the Turks how different things are handled in the EU. Without giving Erdogan (she needs him) grounds for feeling disrespected.

This is now out of the hands of government and will be settled in court. In an independent court that the government will not mess with.

That she emphasized the freedom of speech, freedeom of press and freedom of art several times in her speech is just the cherry on the cake.

There is a strong connection between SAT, spin models and inference in graphical probabilistic models. All can be seen as instances of markov random fields.

They can all be solved with the same algorithms that are very fast for most practical problems.

- With backtracking: https://www.jair.org/media/2648/live-2648-4340-jair.pdf

- With belief propagation: http://web.stanford.edu/~montanar/TEACHING/Stat319/papers/ye...

The lottosonline article is so beside the point. The original paper uses lottery outcomes from all over the world as the seed for "truly random" numbers. For example to define cryptographic curves where no government agency can introduce their magic constants.

On a meta-level, casino and lottery operators have an incentive to push content of that sort. More than once have I been reminded in a casino that the inventor of the Roulette game was a mathematician. "So maybe there is some structure in the results after all".

It's as if they were planting a thought from which the number-crazies and gampling-addicted emerge. There are always some poor souls who think they can crack the code.

But it may be way more profitable. Because profitability is not the amount of dollars earned, but the ratio of earned dollars per invested dollar.

Also, it makes sense for most healthy companies to borrow money and pay out a stock dividend at the same time. You need to pay interest on the borrowed money. But that interest can be deduced from the taxes you'd have to pay otherwise. The trick is to find the correct ratio.

The earnings to invest ratio goes up and everyone is happy.

Python has itertools.product to iterate over the cartesian product of two lists. Some of the most elegant code I ever wrote is due to this abstraction.

https://docs.python.org/2/library/itertools.html#itertools.p...

Discussing edge cases is just the way to find out if a concept (either a technical model or a qualitative worldview) is generally applicable.

Especially if those concepts are touted as being all-encompassing, holding without exception or being superior to other concepts.

Big systems growing over decades are usually easy targets for drastic simplifications by building upon better abstractions.

There's a great talk by Alan Kay titled 'Is it really "Complex"? Or did we just make it "Complicated"?' [1].

He shows for example the Nile system where they replaced several 10k of vector-graphics rendering code with 450 lines. An example from a different context is the miniKanren / microKanren approach to logic programming. It's basically Prolog fitting on a single page [2].

If a similar simplification and unification could be accomplished for representations of (solid) 3D objects, that would be a great great result.

[1] https://www.youtube.com/watch?v=ubaX1Smg6pY [2] http://minikanren.org/

Just use queue.h, as do all the BSDs.

https://github.com/freebsd/freebsd/blob/master/sys/sys/queue...

I went to school with the maintainer at the time (tobgle, ca 2004). He was 14 when he rewrote large parts of the C++ code base. Plus he knew OpenGL.

At that rate, you are limited by context changes from userland to the OS. So you must use an event driven approach like nginx or node.js. In contrast to the Apache way of opening a thread per connection.

Also, make use of netmap: http://info.iet.unipi.it/~luigi/netmap/ That is available for FreeBSD and Linux.

10k messages per sec is doable. But probably not off the shelf.

The guy clearly is technically brilliant. But I was referring to the results. Not how the results were achieved.

In the video, he claims to want to achieve level 3 driving. Let's see how he can do the following under non-perfect conditions:

- switching lanes

- stopping at lights

- turning cornerns

- turning left corners in traffic

Then we can move on to the more difficult situations.

Prototypical case of the 80/20 rule. He has implemented the happy case. But that system is nothing people realistically would want to drive their cars.

What he did is impressive. But the results are not that outlandish for a talented person.

1) Hook up a computer to the CAN-Bus network of the car [1] and attach a bunch of sensor peripherals.

2) Drive around for some time and record everything to disk.

3) Implement some of the recent ideas from deep reinforcement learing [2,3]. For training, feed the system with the oberservations from test drives and reward actions that mimick the reactions of actual drivers.

In 2k lines of code he probably does not have a car model that can be used for path planning [4] (with tire slippage, etc.). So his system will make errors in emergency situations. Especially since the neural net has never experienced most emergencies and could not learn the appropriate reactions.

And guess what, emergency situations are the hard part. Driving on a freeway with visible lane markings is easy. German research projects autonomously drove on the Autobahn since the 80s [5]. Neural networks were used for the task since about the same time [6].

[1] http://www.instructables.com/id/Hack-your-vehicle-CAN-BUS-wi...

[2] http://arxiv.org/abs/1509.02971

[3] http://arxiv.org/abs/1504.00702

[4] http://www.rem2030.de/rem2030-wAssets/docs/downloads/07_Konf...

[5] https://en.wikipedia.org/wiki/Eureka_Prometheus_Project

[6] http://repository.cmu.edu/cgi/viewcontent.cgi?article=2874&c...

Relevant video from juliacon on the type system core: https://www.youtube.com/watch?v=xUP3cSKb8sI

Julia's type system is geared towards JIT compilation. Methods are compiled when they are first called. Then, of course, full type information for the arguments is available. That's quite enough for Matlab-style code with the occasional JITted method. But Julia has one glaring disadvantage for everything beyond that: The return type of methods cannot be specified / enforced.

1) With "black box" methods (where the return type cannot be inferred as in this DataFrames article) the code becomes horribly slow. And you have to dig into the internal method representations to become aware of the type inference results.

2) It hurts the ability of Julia to produce binary executables. When the types are not 100% inferrable, the entire JIT infrastructure needs to be dragged along.

3) Types are not only an aid for the compiler, but also an aid for the programmer. With SIUnits [1] and method return types, Julia could even tell when the physics represented in the code is flawed!!

If Julia's type system were stronger, it could become a prime platform to develop Computer Algebra Systems (CAS). That could lead to a great unification of symbolic and numerical "computation platforms". However, current Julia is unable to represent the mathematics encoded in the type system of open source CAS like Axiom [2]. Also note the github issue on Julia and dependent typing [3].

Imho, there is still a great potential for the Julia type system without breaking existing code.

[1] https://github.com/Keno/SIUnits.jl

[2] http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.27....

[3] https://github.com/JuliaLang/julia/issues/6113

Assembly lines require a huge investment and cannot scale beyond their maximum capacity. So when a car turns out to be popular, the OEM (the brand that does final assembly) or one of the many suppliers might run into a huge backlog.

That is most pronounced when orders spike after the introduction of a new model.

In Europe, only used cars are sold directly off the parking lot or showroom of the dealer.

Normally, you choose the options (color, engine options, leather seats, ..) and the car is built for you. You can pick it up some weeks/months later.

Manufacturers of high-priced cars may invite you to pick up the car at the plant when it comes off the line. They have a special "experience" designed around that.

> Where's a page that says it's a LISP underneath?

Every expression is transformed internally to an AST representation that can be seen as a lisp-style s-expression. And this gets transformed, JIT-compiled, and so on. [1]

Furthermore, the Julia internals contain an entire lisp implementation (femtolisp [2]). That has influenced the metaprogramming capabilities.

> And I didn't see dependent types mentioned in the page below despite some things sounding similar.

Integer matrices can be represented as Array{Int64,2}. So the type of the matrix depends on the Int64 datatype and the dimensionality 2. But that's not necessarily what type theorists understand to be a dependent type. There was an epic discussion that led to the phrasing "dependent" being removed from the Julia docs. [2]

[1] http://julia.readthedocs.org/en/latest/manual/metaprogrammin...

[2] https://github.com/JuliaLang/julia/tree/master/src/flisp

[2] https://github.com/JuliaLang/julia/issues/6113

The Axiom [1] developers created a special purpose dependently typed language to capture mathematical abstractions: SPAD/Aldor [2]. Maxima uses Lisp. [3] These packages contain many man-years of work.

Julia is JIT-compiled, a Lisp (under the hood) and (somewhat) dependently typed.

Is that enough to port (or even transpile) modules from the big open source CAS without an entire rewrite? Is there enough similarity between CAS to make "foreign" modules even a remote possibility?

Otherwise, Nemo will likely not achieve a great unification of math packages, since the required effort goes way beyond the resources of a small dedicated group.

[1] http://www.axiom-developer.org/

[2] http://www.aldor.org/

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

> You are lying at "Third". Angela Merkel publicly encouraged immigrants to come (and die trying) by promising that Germany will host all the people who arrive in Germany and several days later when the reported numbers of immigrants became alarming, Germany and France announced "a plan" (IMPOSSED behind scenes) to distribute the immigrants to other EU states because "solidarity and bla bla bla".

Refugees arriving in Germany have the right to demand asylum. They have that right in every EU country.

But they may be denied asylum (after some months of processing and living in a shelter) if they do not flee from a humanitarian crisis.

The EU is winning this.

It shows that it goes by the humanitarian principles it claims to have. Refugees fleeing from a humanitarian crisis are allowed to stay and to become citizens. People fleeing from a bad economic situation are not.

> But make no mistake this is a total disaster for the refugees, member state Citizens and the EU bureaucracy.

It's a disaster for the refugees. But the disaster is in Syria.

> The damage is so great that Even China and Russia have managed to claim the moral high ground and quit rightly blame the crisis on the EU itself and NATO adventurism in Syria.

You are confused. The US and Turkey are in NATO. But the EU has nearly no involvement in Syria. Besides taking on the fleeing population, that is.

> First, Germany has a problem with social support even for Germans, Hartz 4 is horribly low and injust.

Hartz 4 (long-term unemplyment aid) is basically what the country can sustainably pay without getting into the same debt spiral of Greece, etc. It's enough to survive, but not much more.

> Financial social support is one of the problems currently with the immigrants: It is basically non-existant. No EU region has a lower median salary than this.

During the processing of their asyl request, immigrants get money for housing, food, basic medical services and 140 Euro/month for leisure. Once their asyl request is accepted, they are entitled to the same social aid as any German. But you need to see money in context. Other European countries have a much lower cost of living.

> Second, Immigrants are not guests, they are immigrants or fugitives, and possibly supposed to stay.

Immigrants who are not fleeing from a humanitarian crisis get denied asyl and are expelled.

Printing money is like robbing those who still have cash as the currency is devalued. And it doesn't change a thing if you owe money in foreign currencies.

Otherwise, Japan et al. would have long ramped up the printing presses.

Looks like a bunch of harmonic drive gears in a row. Every industrial robot contains a couple of these.

    The test highlights an issue not covered by micro-
    benchmarking: Encoding and Decoding should perform
    similar, as factual throughput is determined by
    Min(Encoding performance, Decoding performance).
    For unknown reasons JDK serialization manages to encode
    the message tested like 500_000 times per second,
    decoding performance is only 80_000 per second so in
    the test the receiver gets dropped quickly:

At 500,000 messages/sec you can burn 6000 cycles per message on a 3Ghz core.

Probably he has a problem with malloc during the decoding phase. Every malloc and every free costs between 300 (best case) and several thousand cycles (syscall is required).

Norbert Wiener released "Cybernetics: Or Control and Communication in the Animal and the Machine" in 1948. 65 years later, people are still debating the issue and constantly come up with fancy new terms for the subject (i.e. titles for grant proposals).

What I take away from this group is that deterministic communication is required for deterministic system behavior. Well, everybody knew that.

The only thing that surprised me in the field since a long time is that reasoning about continuous and discrete systems is essentially the same [1].

[1] http://symbolaris.net/pub/freedL.pdf