1,529 karma · joined November 22, 2017
True, but two caveats:
1. Neutron bombardment due to fusion makes hardware radioactive for less than 10 years, which isn't great but does not compare to fission waste;
2. Some fusion processes don't emit neutrons (aneutronic fusion). As I understand it, these processes aren't as efficient, but there is the possibility of a tradeoff between generation of ratioactive waste vs. efficiency.
Remote: I can, but prefer on-site
Willing to relocate: Yes. Easy to get visa for US + Commonwealth countries (NZ, UK, Aus, etc)
Technologies: Haskell, Python, Rust (been a while though), SQL, Git.
Résumé/CV: On request -- all details at https://laurentrdc.xyz/about
Email: laurent `dot` decotret `at` outlook `dot` com
---------
I am a physicist with lots of software experience in many domains, including scientific computing, distributed systems, finance & trading, machine learning, and power grid infrastructure.
I maintain several free and open-source software packages: https://github.com/LaurentRDC
I have experience as a scientific software engineer at NASA's JPL, and quantitative research + software engineer at a tech startup. I have also tried starting my own startup in the cleantech space (https://powerweave.io/), which ultimately ran out of runway -- still a valuable experience!
I am interested in climate tech, more specifically the clean energy transition, but willing to hear about anything -- I usually get more interested the more I learn!
However, don't discount renewables. Paired with energy storage -- which isn't only chemical batteries! --, intermittent generation can be extremely useful across vasts parts of North America.
What do you think could have reasonably been awarded?
The possibility that a fully decentralized platform can exist without peer trust still blows my mind.
rustc is enforcing a strong and expressive type system, checking for ownership, generating code from macros, etc. It will always be an order of magnitude slower than C/C++ compiler, kind-of by design.
I should have mentioned that, as you say, monad transformers should be the default effect system choice for 99% of people
Once you've learned what is necessary to, say, modify already-existing applications, you should be familiar with monads and some basic monad transformers like ReaderT.
Once you're there, I don't think 'choosing an effect system' is a perilous question. The monad transformer library, mtl, is an effect system, the second simplest one after IO.
What a beautiful, succinct analogy. I'm stealing this.
I think this comes from early and continuous exposure to some forms of programming, rather than inherent to pure functional programming.
I personally find it much easier to use recursion and other functional techniques because it composes better. This probable comes from my exposure to Haskell much earlier than most.
1. Decide on an effect system
Remember, Haskell is pure, so any side-effect will be strictly explicit. What broad capabilities do you want? Usually, you need to access some program-level configuration (e.g. command-line options) and the ability to do IO (networking, reading/writing files, etc), so most people start with that.
https://tech.fpcomplete.com/blog/2017/06/readert-design-patt...
2. Encode your business logic in functions (purely if possible)
Your application does some processing of data. The details don't matter. Use pure functions as much as possible, and factor effectful computations (e.g. database accesses) out into their own functions.
3. Glue everything together in a monadic context
Once you have all your business logic, glue everything together in a context with your effect system (usually a monad stack using ReaderT). This is usually where concurrency comes in (e.g. launch 1 thread per request).
---
Beyond this, your application design will depend on your use-case.
If you are interested, I strongly suggest to read 'Production Haskell' by Matt Parsons, which has many chapters on 'Haskell application structure'.
The article mentions actor-model frameworks like Akka. Is that not like Ray?
At work we use and maintain something similar called Cloud Haskell (confusingly implemented in a package called distributed-process: https://github.com/haskell-distributed/distributed-process) and I have to say that using it is a breeze.
In general, to keep your mind healthy, it is recommended to continously challenge yourself and learn.
You could do this outside of work hours. Is that an option for you?
The incentives are better aligned to reduce development costs, since Anduril does not earn until products are rolled out.
Maybe this will lead to a cheaper / more efficient defence industry?
Personally I would gravitate towards the quickselect algorithm described in the OP until I was forced to consider a streaming median approximation method.
Edit: yes https://www.independent.co.uk/sport/olympics/enhanced-games-...
Hmmm interesting. I have only seen people rave about it, but haven't used it myself. Why is it shit architecture?
The amount of energy required for AI to be dangerous to its creators is so vast that I can't see how it can realistically happen.
LLMs don't consume more energy when answering more complex questions. That means there's no inherent understanding of questions.
(which you could infer from their structure: LLMs recursively predict the next word, possibly using words they just predicted, and so on).
Unfortunately, dynamically-typed languages haven't adapted the best bit from statically-typed languages: that all types are enforced at compile-time!