Lancer | Code for paper Lancer : Your Code Tell Me | Machine Learning library

I've resolved my issues, there was a problem in the path, that's why i get the 404. Thanks ^^

As Azro said, the problem must be that you are naming your variable with the same name as your function (last_date = last_date(file_path))

Ìn the first iteration of your loop, last_date refer to your function, so last_date() calls your function. When you do last_date = last_date(file_path), last_date does not refer to your function anymore, but instead to your object good_date.

Or, a date object is not callable(it's not a function), that's why you got the TypeError: 'datetime.datetime' object is not callable

Use event.target.checked instead of value.

This is a boolean unlike the value, which you do not set and becomes a string.

here's a working simple example: https://codesandbox.io/s/exciting-dan-m9wxb

In your views you import the rights.py file. When your tests start there is no UserType instances created. When Django tries to set up so that it can start your tests it gets this error because of this fact. You should use the get_or_create method instead to ensure that the objects are created:

To format this correctly, replace

I have read that JAVA 8 supports Tail call optimization, but I am thinking I must not be implementing it correctly.

Then you have read wrong. Or, you've read a correct statement but didn't interpret it correctly.

Java, the language, does not support tail call recursion. It never has. It probably never will*.

However, java, the VM, has a few features that make it easier for other, non-java languages which nevertheless compile into class files to run on a java runtime, to support TCO. That's, presumably, what you read about.

I am just looking for any advice on how to get this to use real tail call optimization, lambda expressions or however I can.

Write it in scala or some such.

TCO is pricey: Java has this rule that when errors occur you get a stack trace, and stack traces are a well defined concept that, crucially, tracks 1 stack frame for each logical call. This cannot continue if TCO exists. There are options, of course: Each individual frame on stack could gain a 'counter' so that the stack trace remains a smallish memory footprint while correctly representing 'and this sequence of calls has recurred 8190581 times'. It's also a boatload of text in the lang spec about how it works, when it does and doesn't kick in, and what it all means, and any additional pages in the spec are maintenance burdens forever - it's not a case of 'it is strictly superior to add TCO to java so when we get around to it, slam dunk, and any Pull Requests with the feature will be integrated immediately'.

Furthermore, TCO as a model is a way of doing things, but it's not the only way. For anything that could be written as a TCO-recursive application, it is generally not all that difficult to refactor that into a loop-based, non-recursing algorithm. Contrast to, say, yield-based async operations, where you can of course rewrite (hey, it's all turing machines), but the rewrite would be difficult, and the resulting code considerably harder to understand. I don't want to get into the value (or lack thereof) of yield/async style coding, just making the point that TCO does not have that veneer of 'ah, but, if TCO is a good idea, then only TCO will do'.

I don't have the links off-hand, but statements in this vein have been said by those who hold quite a bit of sway over the future of java, such as Brian Goetz, Mark Reinhold, etc. If you are really dedicated to try to see this added to java, I suggest you search the web for these statements and then try to shape some arguments specifically to address the concerns they state. Because if you can't convince those folks, it's never going to happen.

Don't use recursion; use while or for instead.

In comments you have linked to this blog entry. That's.. not TCO.

That's using lambdas to write a framework that lets you more or less emulate TCO, but it isn't TCO. The blog describes a little framework - and thus, you need all that stuff they pasted: The TailCall interface in particular.

That code works like this:

• Your 'recursive' method isn't recursive at all, it always returns quickly without calling itself.
• It returns a lambda which may call itself, though. But, as we just covered, calling yourself returns quickly without recursion, and it returns a function.
• The framework will execute your function, which produces, usually, a function (or an actual result). It loops (so no recursion), repeatedly applying the process of: "Call the function. If it returns a function, then loop. If it returns a result, okay, that's the result we wanted so just return that".

That describes what TCO tries to accomplish (repeatedly invoke the same function over and over with different arguments until a hardcoded edge case is reached, and then reverse back out), but doesn't use TCO to do it.

Hence, that blog post saying 'look, TCO in java!' is misleading.

It's like me saying: "Look, paintbrushes on tunnels walls!" and describing how to use cans of spray paint to paint the tunnel wall in a way that looks like it was hand brushed. That is nice, but it's misleading to call it 'paintbrushing a wall'. At best you can say: "Looking to make paintbrush style art in tunnels? Well, you can't, and I can't fix that, but I can tell you how to get similar results!".

*) Never say never and all that, but I mean: There are no plans on the horizon, and the plans for the future of the java platform go many years into the future and are quite public. I'd take 1 to 40 odds on 'java (the language) does not have tail call recursion within 4 years' and still take that bet.

Actually, i did this in my button (and will continue for all my IFs). I just copied the end of the code.

There is a bit that I found after going through this script.

Changes are below.

Your second line Add-type -Assembly System.Windows.Forms are for Windows Forms, not WPF. That should read

The factorial method works fine but you do get relatively consistent overflow when exceeding the stack size. The count for me is somewhere about 9000-10000 calls. Remember that for each recursion, the large values on n! are taking up quite a bit of space in the BigInteger object. So the SO is occurring somewhat early in stack trace.

What I suggest you do is print the values to a file instead of to the console of the IDE. That way you can determine if it is the IDE (probably) or the program (probably not). I know for Eclipse there is an internal buffer size for the console that one must set as well as a max line size.