ChrisFoster

3년 전discuss

Exactly my thought too. The offset is just the zero frequency. But in general, the need to do this for the zero frequency would suggest that there's a scaling problem for all the longer frequency Fourier components? And that, perhaps, the effective spatial Fourier spectrum of noise which is used in Sd is not optimal?

ChrisFoster

4년 전discuss

I'm not sure we're disagreeing here? As I understand it, some people have a certain kind of distractable brain and there's an underlying brain chemistry implicated here which isn't something you develop in adulthood.

However, having this brain chemistry doesn't necessarily mean a person suffers impairments in daily life: impairments are highly situational.

I suppose - to the extent that the DSM-5 requires a fair level of impariment for someone to be diagnosed with ADHD - that it's technically correct to say people can develop this in adulthood: there it passes from a syndrome to an disorder. (Personally I feel it's kind of absurd not to have a name for the syndrome if it occurs in the absence of impariment due to life circumstances! Perhaps this will be "fixed" one day as psychology slowly becomes more quantitative.)

Thanks for the book suggestion!

ChrisFoster

4년 전discuss

ADHD is a developmental condition which is highly genetic and relates to neurotransmitter brain chemistry (Dopamine / Norepinephrine). People with ADHD have it their whole life, it's not something you can develop in adulthood. However, people can be (commonly are) diagnosed in adulthood, especially for the inattentive subtype which has less outward symptoms.

What can change or develop over time is the life circumstances that a person with ADHD finds themselves in. Circumstance can make the difference between ADHD being a disorder with significant impairments vs a joyful and creative existence.

Situations which demand executive function, like putting down that mobile phone or closing youtube in favor of doing something more productive are much harder for people with ADHD. The market built by the tech industry to transact human attention for profit certainly hasn't helped here.

Here's a good brief overview of ADHD: https://www.adhdbitesize.com/post/understand-what-adhd-is-re...

Or a bite-size youtube version https://www.youtube.com/watch?v=xMWtGozn5jU

An online ADHD test which is relatable and seems fairly accurate: https://totallyadd.com/do-i-have-add/

ChrisFoster

5년 전discuss

This is from to the history of how the Julia language was bootstrapped. The fact that Jeff happened to have written his own scheme (femtolisp) as a previous project probably helped :-)

Actually it's not just the parser but most of the compiler frontend which is written in femtolisp. It would be nice to make the frontend more accessible by replacing it with Julia code at some stage. Bootstrapping is tricky though until someone gets separate compilation working.

ChrisFoster

5년 전discuss

That's biologically impossible, but we might end up with weeds which resemble the crop in new and interesting ways.

This has already happened in history for weeds which came under artificial selective pressure due to practices of separating seeds, etc. The fascinating thing is that some of these weeds took on so many of the desirable properties of the primary crop that they became crops in their own right. Rye and oats originally being mimicks of wheat for example: https://en.wikipedia.org/wiki/Vavilovian_mimicry

ChrisFoster

5년 전discuss

I used to think this was true (as a developer of a lot of generic Julia code and small data analysis applications).

But now as a developer of larger amounts of "application style" code, I'm not so sure. In an application, you've got control of the whole stack of libraries and a fairly precise knowledge of which types will flow through the more "business logic" parts of the system. Moreover, you'd really like static type checking to discover bugs early and this is starting to be possible with the likes of the amazing JET.jl. However, in the presence of a lot of duck typing and dynamic dispatch I expect static type inference to fail in important cases.

Static type checking brings so much value for larger scale application work that I'm expecting precise type constraints to become popular for this kind of non-generic code as the tooling matures.

ChrisFoster

5년 전discuss

Have you tried Infiltrator.jl? It's great for breaking out into an interactive REPL from some inner scope, allowing you to examine the local variables and other program state interactively. This covers the part of the functionality of pdb.set_trace() which I care about.

ChrisFoster

5년 전discuss

Yes, well put. I'd take it further - in numerical code there is no real distinction /at all/ between closed form vs iterative solutions. Every type of numerical code is subject to truncation error; an iterative method with few moving parts may systematically converge to a more accurate result than the direct expression of a closed-form solution.

It's quite interesting to delve into how special functions like `sin` and the like are actually implemented and the lengths people go to to make them "correctly rounded" (see, for example, crlibm). Even something as simple as linear interpolation between two floating point endpoints can be quite subtle if you want an implementation that is exactly correctly rounded and also fast.

ChrisFoster

5년 전discuss

This is really neat. In the past I've used similar techniques to decode binary data from a third party lidar system in parallel. In a way that the manufacturers probably didn't intend or expect.

The system generated large data files which we wanted to process in parallel without any pre-indexing. It turned out that these streams contained sync markers which were "unlikely" to occur in the real data, but there wasn't any precise framing like COBS. Regardless, the markers and certain patterns in the binary headers were enough to synchronize with the stream with a very high degree of reliability.

So for parallel processing we'd seek into the middle of the file to process a chunk of data, synchronize with the stream, and process all subsequent lidar scanlines which started in that chunk. Exactly the algorithm they describe here.

Amusingly this approach gave reasonable results even in the presence of significant corruption where the manufacturer's software would give up.

ChrisFoster

6년 전discuss

> it makes a mess of your system that is hard to clean up

This was true in the past, but the Julia ecosystem has rapidly moved away from installing anything via system package managers or messing with the system state in hard to understand ways.

Instead, everything goes into the .julia directory under the control of the Julia package manager, and the dependencies for any given project can be reproduced on another machine or OS by copying the Project and Manifest. The same goes for binary dependencies (eg, the result of compiling C/fortran/rust/go code) for which there's some amazing cross compilation tooling and build infrastructure — see https://binarybuilder.org/

At this point, I think Julia projects enjoy really first class portability and reproducibility.

ChrisFoster

6년 전discuss

The piston idea seems like a appealing design requiring minimal new technology. The plant is the same as existing pumped hydro plant, the weight can come from the native rock.

Using a rolling membrane for the seal is discussed at

https://heindl-energy.com/technical-concept/engineering-chal...

Naively that does seem plausible but it's a very large sheet of material to manufacture. What are your thoughts on that approach?

ChrisFoster

6년 전discuss

No, I'd say it was an almost-complete success. The point of this was to test several things which they've never tested before and gather data to drive design improvements. They successfully tested: ascent under three engines, flap-controlled aerodynamic descent to the landing site, the landing flip maneuver - including drawing propellant from the header tanks - and final landing burn.

They didn't stick the landing, but it looks like they got test data from all the planned test activities. The explosion will prevent gathering some data from post-flight inspection, but other than that I doubt it has much affect on future development.

To look back on SN5/SN6 testing, they stuck the landings with those prototypes, but the prototypes themselves are now obsoleted by the new prototypes in production (up to SN16?!)

ChrisFoster

6년 전discuss

Punning through the union is explicitly allowed in the GCC documentation which explains why it's reliable for use in the Linux kernel. See

https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html#Typ...

> you also have to assume the size of those primitive types

This usually works though there's some situations where you could still be surprised. For instance if you're programming embedded processors with avr-gcc you'll have sizeof(double)==4

ChrisFoster

6년 전discuss

Actually the heat arises from the natural decay of radioactive elements within the Earth. In the far future it will be gone!

It's true that in the early history of the Earth there would have been heating from gravitational contraction of the protoplanetary disc. But as soon as the Earth swept its orbit of material this source of heating disappeared.

There's an interesting footnote in the history of physics where gravitational contraction was the proposed mechanism for solar luminosity: https://en.wikipedia.org/wiki/History_of_Solar_System_format...

ChrisFoster

6년 전discuss

> A function does not spring into existence until the definition of the function is executed.

Methods and their type signatures do exist within the runtime as soon as the function expression is evaluated. To simplify the example from your article

  julia> a = 20
  20

  julia> foo(x::(a < 10 ? Int : Float64)) = "thing"
  foo (generic function with 1 method)

  julia> methods(foo)
  # 1 method for generic function "foo":
  [1] foo(x::Float64) in Main at REPL[2]:1

Here you see that one method of the function foo has been defined, and the code in the type signature has already run, resulting in a method which takes x::Float64. After this point, changing the value of `a` will not change anything about foo.

ChrisFoster

6년 전discuss

I liked the following blog post where Jack Lindamood argues pretty convincingly against using Context.Value in nearly all circumstances, and gives some nice alternatives.

https://medium.com/@cep21/how-to-correctly-use-context-conte...

ChrisFoster

6년 전discuss

Agreed, treating log events as a string seems like throwing a lot of readily available information away. There's various logging libraries which do allow more structure but too often this is ignored.

I think we got some of this right in the standard Julia logging frontend. We allow the user to attach arbitrary key value pairs (name=data) to the event, and also automatically attach some statically known context such as source location.

(The loggers are also dynamically scoped to the task, which has several good properties. For example it gives great control over attaching context known by the caller to the callee's messages and over dynamically routing or filtering messages. Sort of like MDC but more convenient.)

ChrisFoster

6년 전discuss

I agree the exterior algebra is beautifully elegant mathematics, but expressive elegance of the formalism is largely irrelevant to numerical robustness. (Cramer's rule itself is a perfect example of this: it's elementary to express, but in simple form is a terrible idea numerically.)

To be clear, I'm not claiming there's anything wrong with your algorithm but simply adding a note of caution. Any careful comparison between methods must include both efficiency and numerical accuracy.

ChrisFoster

6년 전discuss

In terms of engineering, I can't see how steering this beam would be remotely viable: it appears you've got to line up the long axes of the 1000 km circumference muon ring to point exactly in the direction of the weapon to be targeted. So to have it steerable at all it appears necessary to make it space-based. Having done that, it seems the energy, reaction mass and and time required to steer the thing would be pretty crazy.

From a basic physics viewpoint this seems surprisingly within grasp though in terms of energy scales. Greatly entertaining!

ChrisFoster

6년 전discuss

My main concern with this comparison is that there's no mention of numerical stability / accuracy of this method.

Calculating determinants is notoriously prone to cancellation error if done naively, so you've got to be really careful. By extension, the usual text book implementation of Cramer's rule is a rather bad way to solve matrix systems. (I don't know much about Grassman.jl so perhaps they've used some known tricks to make this work better, but you do have to be really careful with this stuff.)

Actually in early versions of StaticArrays we were pretty cavalier about numerical accuracy because it was just a library we needed for fast geometric calculations. However as people started using this library for serious numerical work we've had to pay a lot more attention to having good numerical properties.

There's still a lot to learn - and no doubt much work to do - in upgrading the implementation to make sure everything is first robust, and second as fast as possible.

comments