svalorzen

The problem with this is that it will not actually parse double in IEEE 754, as you will accumulate inaccuracies at every step of the loop. In theory, when parsing a float, you are supposed to return the floating point that is closest to the original string number. Your code will not do that. Even if you accept the inaccuracy, if you for some reason load the JSON using a runtime library, you'll get different numbers and consequently and result that depend on those numbers. For my use-case this was not acceptable unfortunately..

I recently actually tried to do a very similar thing, although a bit tighter in scope. What stopped me what that actually deserializing floating points cannot currently be done at compile time; the only utility available to do so is `from_chars` and it is only constexpr for ints.

I did not see any mention of this in the post; so are you actually simply extracting the string versions of the numbers, without verifying nor deserializing them?

I mean, surely if you are doing something that requires this level of precision, you could just ask the user to input its current known location? I doubt that even if the user misdialed by ten or twenty meters the difference in compensation would matter (or even if the camera was actually moving around).

Also, in case anyone is interested, the uninformative Jeffreys prior for this in Bayesian statistics (meaning it does not assume anything and is invariant to certain transformations of the inputs) is Beta(0.5, 0.5). Thus the initial guess is 0.5, and it evolves from there from the data.

There is a Vim plugin called EasyMotion, which I absolutely love, which when invoked creates a simple 1 or 2-key "checkpoint" at the start of every word on your screen, and super imposes them on the text. Then it's only a matter of looking at the point where you wanted to move, and press the two keys written there, and there you are!

It's also fairly customizable in that you can specify which characters are actually allowed (so you don't end up with very weird keys to press), and some other stuff. So every time I need to move somewhere I can't be bothered to figure out the standard keys it would take me to get there, it saves me.

> No, not necessarily. Several studies have shown that different people can get different amounts of energy out of the same food, depending amongst others on their gut micro biome, though stress also seems to play a role. It’s never going to be that simple.

Sure, so they just need to compute their at-rest calorie consumption differently, and from there the rest is the same.

> Conventional thermodynamics don’t work when you consider a full human, which is a very out-of-equilibrium and not-isolated system. Conservation of energy does not tell you anything about the efficiency of the energy extraction process.

This is like saying that even if you don't refuel your car it will never stop, because different cars have different mpg ratings. A human is indeed a closed system when you consider the works it outputs and the calories it ingests, unless I somehow missed a newfound capacity for photosynthesis. The fact that it might be a bit harder to compute calorie requirements than what might be naively done does not allow you to just dismiss everything else.

Hasn't your bet already been beat in concept by https://en.wikipedia.org/wiki/L%C3%A1szl%C3%B3_Polg%C3%A1r ?

He is a chess teacher who decided to train his daughters in chess from a very young age. What do you know, two of them became the first and second best players, with the best being considered the best woman chess player of all time. Unlikely that they somehow just all got chess genius "genes" from him.

It really does seem that heavy investment from a young age by a good teacher can work wonders.

I thought about this for a bit, and I have a feeling that as long as everything is touching the ground, then making covering loops is impossible, and so there exist a simple ordering you can compute.

The ordering is as follows: I'm assuming the isometric rendering of a map as a 45 degrees tilted square, and I'm only considering tile ordering just for simplicity but it should generalize fine. The uppermost tile is where you want to start rendering. From there, you render following the two 45 degree diagonals until you are done (so you don't only look at the y axis). Once this is done, you restart the process from the tile just below the uppermost corner, and so on. This ordering makes sure that all rectangular objects that are aligned with the 45 degree diagonals are rendered correctly.

Now you need an additional trick to render rectangular objects that are transversal to those diagonals correctly. What you do is you keep track of the boundaries of all such objects, so that the rendering loop described above can tell when it encounters one. Once it encounters it, it pauses rendering the current diagonal and considers it temporarily complete. The diagonal on the other side still needs to be rendered fully though --- or at least as far as possible with the same stopping condition. The next rendering pass will likely at some point re-encounter the same transversal object, just at a further point. Stop again, start the next diagonal. Once the rendering encounters the lowest and last part of the transversal object, then that object can be rendered, and the first stopped diagonal can be resumed (and after this resume all the paused diagonals in order).

This should always give you the correct order to render everything without errors. Let me know if this made sense, otherwise I can try to clarify.

We document that the ban on dumping dioxins in rivers has induced the exit of a number of chemical plants; and following implementation entry of dangerous chemical handling facilities fell by half. Whatever the health benefits of banning dioxins, they come at substantial costs of forgone innovation.

I'm not sure I understand why dynamic programming wouldn't work (and the author explicitly mentioned Knuth). Tex's main job is literally doing line breaks, which is the exact same problem being tackled here. I would expect a similar approach (progressively build a graph of the most promising breaking points) to be effective. Why wouldn't it be the case here?

Hi, I'm the author of a C++ library focused on tabular bandits, mdps and pomdps. It's called AI-Toolbox, and it's one of the largest non NN libraries out there.

The library is fully documented, but the text is probably a bit dry. I'd love for somebody to help me improve its accessibility, and I'd be willing to help them along learning how things work.

My email is my nickname and Gmail, feel free to reach out if you are interested.

When you look at something like Borat's swimming suit, it is ridiculed specifically because it is sexualized. However, for men that swimming suit generally results in a negative sexual interest, and it's why you hardly find men wearing it. In gay parades you find plenty of men wearing ultra tight shorts, specifically because they sexualize. How can't they? They are specifically designed to highlight the genital areas.

As a second point about breasts, human breasts are unique in the animal kingdom because they are specifically made to signal sexual availability. Generally animals do not have enlarged breasts, even when lactating. In humans the woman breast evolved to enlarge when sexual maturity is reached to signal sexual availability. So saying that boobs are just a body part that men sexualize is also incorrect.

> So leave.

This is like being unwillingly thrust on the top antenna of a skyscraper, barely hanging on, and you saying "Don't like it here? Then jump."

Nice work! I maintain a library, cpp-readline [1], with a very similar API. The main difference is that relegates the REPL part to GNU readline. You do have the additional dependency, but on the other hand it automatically adds history and other nice-to-have features.

[1]: https://github.com/Svalorzen/cpp-readline

> you are your job

I'm sorry to say this, but this is one of the saddest things a person can say in my opinion. You can definitely become your job, but I can't see myself ever wanting something like that.

Not an English native as well, but in my language it works in the same way. "My" is used to designate possession of the set, not of the individuals. I don't own "my friends" as a slave owner, they are "my friends" because that is my personal set of friends among all possible sets of people.

What I realized after many long discussions with my friends is that the largest discrepancies in opinions often originate from a simple different assumption. The difficult part is discussing long enough to figure out what that assumption is, since it's usually so fundamental (for both parties) to the whole belief that you have to spend a long time arguing about the "obviously" wrong statements of the other person.

When you figure what the assumption is, it's basically guaranteed to make you agree with each other: "Ah, but so you believe A! Of course you'd argue for A' then, makes total sense now!" It's then much easier to find compromises since you can work on the small thing below rather than the whole scaffold built on top.

Unfortunately I haven't yet found a way to easily discover what the differing assumption is aside from lengthy debates. This makes finding compromises with people harder as you can only discuss in depth with people where you can trust that they are truly arguing in good faith.

Every time there is a post like this I go check the license of the original project. Invariably, it is MIT. I think this is probably indicative of something, although I couldn't say what.

I maintain a repository of many implementations of classical (tabular) RL algorithms [1] which you might enjoy playing with when starting out. I use it for both research and for student projects. The advantage of avoiding NNs when starting out is that it is much simpler to inspect the inner workings of an algorithm to see whether it's working or not.

I'm always happy to help if something is unclear or difficult so feel free to open issues there :)

[1]: https://github.com/Svalorzen/AI-Toolbox

Are you sure about this? In my tests floating points are always considered partially ordered, not totally ordered. This page [0] even mentions this in the notes towards the bottom.

[0]: https://en.cppreference.com/w/cpp/utility/compare/partial_or...

This is what I also do. I rebase all my branches and merge them with a no-fast-forward commit, which does not introduce any changes itself, but can be used to document the overall changes of a specific feature.

The best part about this workflow is that history remains linear; it is very easy to track the history of changes (since there is never a "branch" with changes on both sides) while at the same time you keep the ability to visualize where the start/end points for a given feature were.

It also works with nested branches! You simply create a new branch2 from your branch1, and then merge --no-ff branch2 to branch1.

Sorry to sidetrack, but I'm also interested in implementing a Tex engine (in another language though). Any suggestions on how to learn how an engine works?

Yes... and no. It is true that after a result is obtained, one could clean up the code for publication. And it is true that coding is not seen add first class at the moment.

At the same time, you need to consider that such a clean up is only realistically helpful for other people to check whether there are bugs in the original results, and not much else. Reproducing results can be done with ugly code, and future research efforts will not benefit from the clean up for the same reasons I outlined in my previous post.

While easing code review for other people is definitely helpful (it can still be done if one really wants to, and clean code does not guarantee that people will look at it anyway), overall the gains are smaller than what "standard" software engineers might assume. And I'm saying this as a researcher that always cleans up and publishes his own code (just because I want to mostly).

I don't really agree with the reasons given, even though my conclusions are the same. The main reason why research code becomes a tangled mess is due to the intrinsic nature of research. It is highly iterative work where assumptions keep being broken and reformed depending on what you are testing and working on at any given time. Moreover, you have no idea on advance where your experiments are going to take you, thus giving no opportunity to structure the code in advance so it is easy to change.

To make a concrete example, imagine writing an application where requirements changed unpredictably every day, and where the scope of those changes is unbounded.

The closest to "orderly" I think research code can become would be akin to Enterprise style coding, where literally everything is an interface and all implementation details can be changed in all possible ways. We already know how those codebases tend to end..

If you are ever interested in the topic of RL, but wish to start learning the concepts on simpler algorithms and keep the "deep" part for later, I maintain a library that has most of the same design goals:

https://github.com/Svalorzen/AI-Toolbox

Each algorithm is extensively commented, self-contained (aside from general utilities), and the interfaces are as similar as I could make them be. One of my goals is specifically to help people try out simple algorithms so they can inspect and understand what is happening, before trying out more powerful but less transparent algorithms.

I'd be happy to receive feedback on accessibility, presentation, docs or even more algorithms that you'd like to see implemented (or even general questions on how things work).

I apologize if using hyperboles makes my point less clear. I'm not literally advocating Alaska, I'm trying to make the point that cities as we currently know them only exist because they are the most efficient solution when the population mostly has to work in the same location. Once you remove this constraint, it's much more viable to have smaller and more distributed population centers, without necessarily resorting to living alone in Alaska. This would still significantly reduce rents, and even better allows competition between distant locations which wouldn't otherwise be competing on prices.

For the other point, UBI as I know it must be financed by some sort of increased taxation of the rich, it is not the government blindly printing money and distributing it. I don't know whether that taxation should be LVT or something else, I'm simply talking about why the argument that UBI doesn't work due to rent is, in my opinion, incorrect.

Personally, I really hate this comment, for several reasons.

First, let's consider the price of the rent. Assume for a moment that somebody manages to fix all mental health problems, alcoholism and so on, and that magically everyone manages to find a good job that pays reasonably well. This is supposedly the dream land of the pure capitalists: everyone works and is productive and so no handouts are received. Well, what would you suppose happens to the rent in this situation? If everyone is able to pay, then rents would go up, wouldn't they? So the difference between UBI and this is only that in one case people don't necessarily have to work, while in the latter case they have to spend 8+ of their lives doing stuff they may not like.

What this means is that your main point is simply that you don't want people to have money to pay for housing, because that may make prices go up for you. You are literally advocating that some people must be homeless so that life for us is easier.

Secondly, the rent argument consistently ignores the fact that if you don't have to work, you can go live wherever you want. One could go live in Alaska and buy 1km2 of land for 10$ because who gives a shit? construct their own igloo or something and then live there forever. This would additionally free them up to spend a larger part of UBI on other products. Instead there is this weird assumption that people will forever cluster in SF or other highly populated centers, because apparently humans are ants and like to breathe pollution.

I don't think the author is advocating for less education. The thing is that completing a university course awards you with a title which should in theory certify that you have completed some material and you understand it very well.

If that is not the case the world will automatically try to get the next best certification possible. In the world of old just being able to read was seen as a mark of excellence; once that was the norm it became having finished basic schooling. After WW2 having any kind of university degree was synonymous with intelligence, today lots of jobs start requiring a PhD in order to filter out high-level candidates.

This could go on and on forever but the only thing we are achieving is making everybody lose more and more time in school trying to get a piece of paper. This is extremely wasteful and can be simply corrected by making schools actually hard. Then the qualifications will go back to being a premium which most companies will not actually need (rather than bartenders needing a bachelor's degree).

There's also an additional disadvantage of having the bar low: you help discredit actual science by having hordes of barely-passable "experts" which say whatever they want to say. In my parent's time when somebody was a doctor or engineer people would listen very carefully; today nobody even believes global warming or vaccines because so many qualified "scientists" keep barfing random opinions out. This is a serious problem because it undermines the public's trust towards serious issues, and while there's no easy solution raising the bar in universities would certainly help.

RL is actually quite an umbrella term for a lot of things. There's policy gradient methods, which improve directly on the policy to select better actions, there's value based methods which try to approximate the value function of the problem, and get a policy from that, and there's model based methods which try to learn a model and do some sort of planning/processing in order to get the policy.

Using model based methods can allow you to do some pretty fancy stuff while massively reducing the number of data samples you need, but on the other side there's a trade off. Using the model usually tends to require lots of not-very-parallelizable computations, and can be more costly computationally. Very large problems can get out of hand pretty quickly, and there's still a lot of work to do before there is something which can be applied in general quickly and efficiently.

If you ever feel like trying out the algorithms contained in the book without going to the trouble of reimplementing everything from scratch feel free to come over to https://github.com/Svalorzen/AI-Toolbox. This is a library I have maintained during the past 5 years and implements quite a lot of RL algorithms, and can be used with both C++ and Python. It's very focused on being understandable and having a clear documentation, so I'd love to help you out starting up :)