Just played a round, pretty fun! Thanks for sharing.
68 karma · joined March 22, 2018
https://github.com/Mitchellpkt/infinite_adversarial_langtons...
I wonder why you can’t get it to give approximations. I have not encountered difficulties there. I asked it to approximate the weight of argon in the atmosphere and it performed a fairly standard back of the envelope calculation. Do you want to share a particular prompt, so I can try and reproduce the issue you're experiencing?
On any Nth iteration, the ant has only touched <= N tiles. Suppose we do a thought experiment where we create a second board that is empty except for the initial states of the touched tiles up to the Nth step. This second board has finite support, and so the usual theorems kick in, and consequently the ant will eventually start building a highway that would carry it away from the initial loop.
I’m just making up guesses though, I have no clue if that is right.
What I am curious about is whether these boards/procedures exist, and how to find them.
The adversarial objective is twofold: primary is the prevention of 'highway' construction by the ant, and secondary, if the primary objective cannot be fully achieved, is to disrupt the 'highways' as swiftly as possible post-formation.
I do not have a good intuition for who has the upper hand here. The adversary can be deliberate, but its influence is strictly limited to controlling initial conditions of the board.
Maybe this falls under the Cohen-Kong Theorem, or a potential extension of it. I'm not sure whether that applies here since the adversary may provide a board with finite support or may choose to instead provide a board (or board-generating procedure) with infinite support.
> Copilot for CLI provides three shell commands: `??`, `git?` and `gh?`:
> `??` is meant as the general-purpose goto for arbitrary shell commands. It will compose commands and loops, and throw around obscure find flags to satisfy your query.
> `git?` is used for searching specifically for git invocations. Compared to ?? it will be more powerful at generating Git commands, and your queries can be more succinct when you don't need to explain that you're in the context of Git.
> `gh?` combines the power of the GitHub CLI command and query interface with the convenience of having AI generate the complicated flags and jq expressions for you.
On 27-Mar 2023 I registered for some of the "X" waitlists.
On 13-Apr 2023 I received an email with the subject line "Welcome to the Copilot for CLI technical preview!"
Note that the "X" is a placeholder and not one of the actual products you can try. From their website [1]:
> The “X” represents a placeholder for where we intend GitHub Copilot to become available, and what we expect it to be capable of doing (e.g. “Copilot <for pull requests>“, “Copilot <for security>“). It is extending the product from one experience, code completion, to X experiences across the developer’s workflow.
Now, I just use the first 2 and last 2 letters, so for example hackernews would be haws@myname.com. When I go back later to log in, it is easy to re-derive on the spot. And if I forget what an email address corresponds to I can just search my inbox history for that address to find the site registration confirmation or whatever they sent previously.
The Uniswap mechanism varies significantly by version number:
+ For k=x*y mechanism used in Uniswap v2, check out [2] "Improved Price Oracles: Constant Function Market Makers" and/or the [3] the Uniswap V2 whitepaper.
+ For newer liquidity range mechanism, there is a very nice explanation in [4] the Uniswap v3 core whitepaper.
-----
0. https://cryptoeconomicsystems.pubpub.org/pub/angeris-uniswap...
1. https://cryptoeconomicsystems.pubpub.org/pub/angeris-curvatu...
2. https://dl.acm.org/doi/abs/10.1145/3419614.3423251
I don’t think you should feel too discouraged. Plenty of companies do not allow their developers to use third party language models/services (due to privacy, legal, or other concerns) so they’ll have plenty of standard unassisted dev work. And for the companies that do leverage the tech, your experience with it will make you an even stronger candidate.
I like it, especially when doing dev work with only one monitor. You might hate it, but it’s worth giving it a shot.
I was halfway through "Revelation Space" by Alastair Reynolds when ChatGPT was released. Throughout the book, it is common for characters to use natural language to delegate technical tasks to AI helpers, and then review the results later.
As somebody who does a lot of technical work and had hands-on experience with GPT-2 this seemed quite implausible. A few months ago I couldn't just instruct an AI to go find X and Y and then calculate Z and show me a visualization of that.
But now with copilot, Bing, ChatGPT, et al this is a pretty standard task! Using natural language to instruct an AI to find some information or write a first rough draft of some code is no longer some far-future fiction.
The timing with ChatGPT dropping when I was halfway through the book meant that one of the elements of its world went from feeling very "sci-fi" to being quite ordinary. o_0
A black box AI algorithm that generates shirts in a video game? Sure, sign me up. Worst case scenario the shirt looks weird or the game crashes. I’ll live on the edge a little and file some bug reports.
A black box AI algorithm that handles critical safety systems? This requires more thoughtful scrutiny.
[usual disclaimers: LLMs hallucinate, never trust their output without review and testing, etc]
Not saying there is no place for synthetic data. Just needs to be in situations where the salient dynamics are well understood such that they are realistically reproduced in the generated data.
Experience: It was a bit of a learning curve, but a manageable one. I think maybe 80% of my energy went into improving my domain expertise (physical chemistry) and 20% went into learning enough coding & scripting to execute the research.
How / Courses: Never took any coding classes myself, but in retrospect I think it would have helped me move quicker if I'd at least taken an online course to brush up on the basics. I'd try to solve problems on my own for an hour or two, and ask somebody if I got stuck for too long. I think the main drawback here is that I was able to break through any given concrete problem (why is this code throwing an exception? why is this array all NaNs? why is time negative?) but never learned big picture patterns for writing reliable, extensible, and reusable codebases. I probably could have moved quicker if I'd started learning & thinking about that sooner.
Languages: If you can, use open source languages (e.g. python) where possible. One of my biggest regrets is that I did 100% my thesis work in MATLAB, which requires an annual software license that was paid for by my university. Now that I've graduated, I can't run or work on my own research, even though my code is not proprietary. (You may not have a choice in some cases, e.g. one of the key models in my field was implemented it MATLAB, but I could have done some of the other work in python).
Later digging: I've picked up more software engineering and computer science skills since grad school, but that's because there is more emphasis on performance and code hygiene in industry. For my grad school research, it was VERY important that the code produced the right numeric results, but nobody cared if it was fast or pretty.
Things it would have been helpful to learn earlier: version control (how to use GitHub and atomic commits to never lose work), writing tests for core functions that might fail in non-obvious ways, clean handling of parameter & configurations, etc. Oh, and comments! During an REU I spent an entire summer writing spaghetti Perl code with no notes; a year later the professor asked me to re-run something, and I had to spend a week reverse engineering my own work.
It took some work and intention to slow down and learn to actually imagine the world that the author is laying out for us. But like any other learned habit it becomes easier and eventually not noticed with practice.
Finding engrossing fiction (in my case, science fiction) helped me break through. Given your references to visualizing physics, you might enjoy the first book or two of the Three Body Trilogy.
Once I understood fstrings, list/dict/set comprehension, and tuple unpacking, it became much easier to read and learn from others' python code.
I would still read all my emails at the end of the day, but having important state changes (e.g. lead becoming qualified, or a time-sensitive ask from management) highlighted sooner would have been convenient.
The great news is that many of these products are free or relatively inexpensive, so you can start gaining experience with them today.
The best way to future-proof your career in the event that language models become widely applied is to make it one of your core competencies. :)
If you start practicing today, you'll quickly be at the front of the curve. And try to practice deliberately, for example gaining experience with:
- how to give it all the necessary information and nothing superfluous,
- how to effectively articulate the desired deliverable and its requirements,
- how to guide it through iterating on the solution and when to stop (often I do the first 10% of the work, then the model does the next 60% of the heavy lifting, and then I finish off the last 30% to fix its mistakes and tailor the result)
On the other hand I become frustrated when ads are blocking features that I am trying to interact with, and require me to click to close. I have uninstalled apps over this.
Appreciate your thoughtfulness on this matter, good luck!
(Edit: autocorrect typo)
While I can't offer you a formal cryptanalysis, I do have a handwave-y thought experiment & proof by contradiction for intuition:
Consider two encryption algorithms A[...] and B[...] that are "good" in the standard ways (adversary cannot decrypt messages without keys, keys cannot be leaked by chosen plaintext attack, etc).
If putting A inside of B like B[A[...]] renders the system insecure, it would imply that B[...] was not a "good" encryption function! (if it was good, it would not break just because the input message happens to be the output of A[...]).
Therefore by handwave-y proof by contradiction, if A[...] and B[...] are "good", then A[B[...]] should be OK.
(Disclaimer: Again, this is a casual thought experiment and not real cryptanalysis. This result may not be true under formal cryptanalysis.)
There's a useful asymmetry we can exploit: finding weights that perform well is computationally intensive and takes time, but scoring a set of weights is fast and easy.
A number cruncher could spend 2 weeks training a model, and then when they submit the results it takes me 10 seconds to score the model - to verify the quality of the results, and calculate the performance-based payout. In the #1 or #3 scenario where they didn't do or didn't complete the computations, they wouldn't have a well-trained model to submit for payout. (The lost time in #3 is inconvenient in time-sensitive situations, but mechanisms exist to address that - SLAs, up-front collateral, etc)
Regarding privacy, that's an EXTREMELY good and important question. There's some really neat prior art for privacy-preserving machine learning that could be useful here, e.g. https://arxiv.org/abs/2106.07229 "Privacy-Preserving Machine Learning with Fully Homomorphic Encryption for Deep Neural Network"
(note I'm approaching this as an interesting DistML thought experiment, not proposing it as an immediately viable or sensible initiative)