Search
1000 results for “Manamin”
-
🤖☕️ So, Andon Labs unleashed their #Skynet wannabe, #Mona, to run a café in #Stockholm, because nothing screams "cutting-edge AI" like barely managing a hipster #coffee #shop. After dodging Swedish bureaucracy like a malfunctioning Roomba, it's a miracle Mona didn't just serve existential dread with your espresso. 😏📉
https://andonlabs.com/blog/ai-cafe-stockholm #AI #AndonLabs #TechHumor #HackerNews #ngated -
🤖☕️ So, Andon Labs unleashed their #Skynet wannabe, #Mona, to run a café in #Stockholm, because nothing screams "cutting-edge AI" like barely managing a hipster #coffee #shop. After dodging Swedish bureaucracy like a malfunctioning Roomba, it's a miracle Mona didn't just serve existential dread with your espresso. 😏📉
https://andonlabs.com/blog/ai-cafe-stockholm #AI #AndonLabs #TechHumor #HackerNews #ngated -
🤖☕️ So, Andon Labs unleashed their #Skynet wannabe, #Mona, to run a café in #Stockholm, because nothing screams "cutting-edge AI" like barely managing a hipster #coffee #shop. After dodging Swedish bureaucracy like a malfunctioning Roomba, it's a miracle Mona didn't just serve existential dread with your espresso. 😏📉
https://andonlabs.com/blog/ai-cafe-stockholm #AI #AndonLabs #TechHumor #HackerNews #ngated -
EPFO tightens rules for private trusts with new SOP
Over 1,250 private trusts managing more than ₹3.50 lakh crore life-savings of nearly 3.2 million employees will have…
#NewsBeep #News #Personalfinance #AU #Australia #Business #Employees’ProvidentFundOrganisation #EPFO #Finance #newstandardoperatingprocedure #PersonalFinance #PrivateTrusts #providentfund
https://www.newsbeep.com/au/664948/ -
EPFO tightens rules for private trusts with new SOP
Over 1,250 private trusts managing more than ₹3.50 lakh crore life-savings of nearly 3.2 million employees will have…
#NewsBeep #News #Personalfinance #AU #Australia #Business #Employees’ProvidentFundOrganisation #EPFO #Finance #newstandardoperatingprocedure #PersonalFinance #PrivateTrusts #providentfund
https://www.newsbeep.com/au/664948/ -
Relating to my last post, what is the best way to encode chatbot discourse processes?
In the past, with IBM Watson and similar, the process was pretty strictly defined like this:
1. Interrogate the user to find out which procedure they need.
2. Select procedure, the procedure is a web form which requires a set of inputs from the user. Name, date of reservation, number of people eating, special preferences, those sorts of things.
3. Interrogate the input fields from the user to fill up the form.
4. When the form is done, confirm from the user that it it fine, and then submit it.
Ok, nowadays the chatbots are way more versatile, but for some cases the above workflow is still fine. For more complex use cases we can take inspiration from role-playing games and robotics:
Behavior Trees!
https://shorturl.at/bKWY1With behavior trees you can compose pretty complex discourse processes without the complexity becoming unmagageable. You can easily isolate the specific process parts while having many simultaneous options open for the chatbot.
It's a very powerful architectural pattern which is very relevant in this context. It's a generalization of the old Watson scheme and can easily encode those types of processes as well.
Note also that while the chatbot processes in the past were designed to constrain and guide the user, as the user was the intelligent element making choices and evaluations, now the chatbot is also an intelligent element and makes choices and evaluations as well. So the process gets conditions and triggers from both the user/client and the chatbot, and also from your runner module and your backend systems.
To be clear, the behavior trees are not running on the user or on the bot, they are run on the runner process. They herd both the user and the bot to conclusions of specific procedures.
Why are behavior trees needed, why not just give the bot the information about what is needed and let it run the process?
First of all the prompt size limits. If you describe your process to the bot, it eats your context limits very quickly. Also, the bot tends to improvise, which further makes you add stuff to the prompts to reduce that.
It is much better to feed the process to the bot in pieces only when needed.
Also, when you need for example something machine readable to produce some complex item, and also something human-readable to describe the same, it often makes sense to first tell the bot to describe in human-readable prose what its evaluation or conclusion is, and then separately tell it to produce the same in a machine-readable form. Then you get the two outputs separately which your runner process combines into a conclusion.
That would be a sequential node in a behavior tree executing through the human-readable output first and then the machine-readable output.
All the #AutoGPT style agents and other processes can also be described as behavior trees. Just feed the chatbot think-command step prompts in sequence while separately managing the backend as per commands.
Plug-ins become pluggable #BehaviorTrees, which might be as simple as describing the end point and handling the related commands.
-
Relating to my last post, what is the best way to encode chatbot discourse processes?
In the past, with IBM Watson and similar, the process was pretty strictly defined like this:
1. Interrogate the user to find out which procedure they need.
2. Select procedure, the procedure is a web form which requires a set of inputs from the user. Name, date of reservation, number of people eating, special preferences, those sorts of things.
3. Interrogate the input fields from the user to fill up the form.
4. When the form is done, confirm from the user that it it fine, and then submit it.
Ok, nowadays the chatbots are way more versatile, but for some cases the above workflow is still fine. For more complex use cases we can take inspiration from role-playing games and robotics:
Behavior Trees!
https://shorturl.at/bKWY1With behavior trees you can compose pretty complex discourse processes without the complexity becoming unmagageable. You can easily isolate the specific process parts while having many simultaneous options open for the chatbot.
It's a very powerful architectural pattern which is very relevant in this context. It's a generalization of the old Watson scheme and can easily encode those types of processes as well.
Note also that while the chatbot processes in the past were designed to constrain and guide the user, as the user was the intelligent element making choices and evaluations, now the chatbot is also an intelligent element and makes choices and evaluations as well. So the process gets conditions and triggers from both the user/client and the chatbot, and also from your runner module and your backend systems.
To be clear, the behavior trees are not running on the user or on the bot, they are run on the runner process. They herd both the user and the bot to conclusions of specific procedures.
Why are behavior trees needed, why not just give the bot the information about what is needed and let it run the process?
First of all the prompt size limits. If you describe your process to the bot, it eats your context limits very quickly. Also, the bot tends to improvise, which further makes you add stuff to the prompts to reduce that.
It is much better to feed the process to the bot in pieces only when needed.
Also, when you need for example something machine readable to produce some complex item, and also something human-readable to describe the same, it often makes sense to first tell the bot to describe in human-readable prose what its evaluation or conclusion is, and then separately tell it to produce the same in a machine-readable form. Then you get the two outputs separately which your runner process combines into a conclusion.
That would be a sequential node in a behavior tree executing through the human-readable output first and then the machine-readable output.
All the #AutoGPT style agents and other processes can also be described as behavior trees. Just feed the chatbot think-command step prompts in sequence while separately managing the backend as per commands.
Plug-ins become pluggable #BehaviorTrees, which might be as simple as describing the end point and handling the related commands.
-
Relating to my last post, what is the best way to encode chatbot discourse processes?
In the past, with IBM Watson and similar, the process was pretty strictly defined like this:
1. Interrogate the user to find out which procedure they need.
2. Select procedure, the procedure is a web form which requires a set of inputs from the user. Name, date of reservation, number of people eating, special preferences, those sorts of things.
3. Interrogate the input fields from the user to fill up the form.
4. When the form is done, confirm from the user that it it fine, and then submit it.
Ok, nowadays the chatbots are way more versatile, but for some cases the above workflow is still fine. For more complex use cases we can take inspiration from role-playing games and robotics:
Behavior Trees!
https://shorturl.at/bKWY1With behavior trees you can compose pretty complex discourse processes without the complexity becoming unmagageable. You can easily isolate the specific process parts while having many simultaneous options open for the chatbot.
It's a very powerful architectural pattern which is very relevant in this context. It's a generalization of the old Watson scheme and can easily encode those types of processes as well.
Note also that while the chatbot processes in the past were designed to constrain and guide the user, as the user was the intelligent element making choices and evaluations, now the chatbot is also an intelligent element and makes choices and evaluations as well. So the process gets conditions and triggers from both the user/client and the chatbot, and also from your runner module and your backend systems.
To be clear, the behavior trees are not running on the user or on the bot, they are run on the runner process. They herd both the user and the bot to conclusions of specific procedures.
Why are behavior trees needed, why not just give the bot the information about what is needed and let it run the process?
First of all the prompt size limits. If you describe your process to the bot, it eats your context limits very quickly. Also, the bot tends to improvise, which further makes you add stuff to the prompts to reduce that.
It is much better to feed the process to the bot in pieces only when needed.
Also, when you need for example something machine readable to produce some complex item, and also something human-readable to describe the same, it often makes sense to first tell the bot to describe in human-readable prose what its evaluation or conclusion is, and then separately tell it to produce the same in a machine-readable form. Then you get the two outputs separately which your runner process combines into a conclusion.
That would be a sequential node in a behavior tree executing through the human-readable output first and then the machine-readable output.
All the #AutoGPT style agents and other processes can also be described as behavior trees. Just feed the chatbot think-command step prompts in sequence while separately managing the backend as per commands.
Plug-ins become pluggable #BehaviorTrees, which might be as simple as describing the end point and handling the related commands.
-
Relating to my last post, what is the best way to encode chatbot discourse processes?
In the past, with IBM Watson and similar, the process was pretty strictly defined like this:
1. Interrogate the user to find out which procedure they need.
2. Select procedure, the procedure is a web form which requires a set of inputs from the user. Name, date of reservation, number of people eating, special preferences, those sorts of things.
3. Interrogate the input fields from the user to fill up the form.
4. When the form is done, confirm from the user that it it fine, and then submit it.
Ok, nowadays the chatbots are way more versatile, but for some cases the above workflow is still fine. For more complex use cases we can take inspiration from role-playing games and robotics:
Behavior Trees!
https://shorturl.at/bKWY1With behavior trees you can compose pretty complex discourse processes without the complexity becoming unmagageable. You can easily isolate the specific process parts while having many simultaneous options open for the chatbot.
It's a very powerful architectural pattern which is very relevant in this context. It's a generalization of the old Watson scheme and can easily encode those types of processes as well.
Note also that while the chatbot processes in the past were designed to constrain and guide the user, as the user was the intelligent element making choices and evaluations, now the chatbot is also an intelligent element and makes choices and evaluations as well. So the process gets conditions and triggers from both the user/client and the chatbot, and also from your runner module and your backend systems.
To be clear, the behavior trees are not running on the user or on the bot, they are run on the runner process. They herd both the user and the bot to conclusions of specific procedures.
Why are behavior trees needed, why not just give the bot the information about what is needed and let it run the process?
First of all the prompt size limits. If you describe your process to the bot, it eats your context limits very quickly. Also, the bot tends to improvise, which further makes you add stuff to the prompts to reduce that.
It is much better to feed the process to the bot in pieces only when needed.
Also, when you need for example something machine readable to produce some complex item, and also something human-readable to describe the same, it often makes sense to first tell the bot to describe in human-readable prose what its evaluation or conclusion is, and then separately tell it to produce the same in a machine-readable form. Then you get the two outputs separately which your runner process combines into a conclusion.
That would be a sequential node in a behavior tree executing through the human-readable output first and then the machine-readable output.
All the #AutoGPT style agents and other processes can also be described as behavior trees. Just feed the chatbot think-command step prompts in sequence while separately managing the backend as per commands.
Plug-ins become pluggable #BehaviorTrees, which might be as simple as describing the end point and handling the related commands.
-
Relating to my last post, what is the best way to encode chatbot discourse processes?
In the past, with IBM Watson and similar, the process was pretty strictly defined like this:
1. Interrogate the user to find out which procedure they need.
2. Select procedure, the procedure is a web form which requires a set of inputs from the user. Name, date of reservation, number of people eating, special preferences, those sorts of things.
3. Interrogate the input fields from the user to fill up the form.
4. When the form is done, confirm from the user that it it fine, and then submit it.
Ok, nowadays the chatbots are way more versatile, but for some cases the above workflow is still fine. For more complex use cases we can take inspiration from role-playing games and robotics:
Behavior Trees!
https://shorturl.at/bKWY1With behavior trees you can compose pretty complex discourse processes without the complexity becoming unmagageable. You can easily isolate the specific process parts while having many simultaneous options open for the chatbot.
It's a very powerful architectural pattern which is very relevant in this context. It's a generalization of the old Watson scheme and can easily encode those types of processes as well.
Note also that while the chatbot processes in the past were designed to constrain and guide the user, as the user was the intelligent element making choices and evaluations, now the chatbot is also an intelligent element and makes choices and evaluations as well. So the process gets conditions and triggers from both the user/client and the chatbot, and also from your runner module and your backend systems.
To be clear, the behavior trees are not running on the user or on the bot, they are run on the runner process. They herd both the user and the bot to conclusions of specific procedures.
Why are behavior trees needed, why not just give the bot the information about what is needed and let it run the process?
First of all the prompt size limits. If you describe your process to the bot, it eats your context limits very quickly. Also, the bot tends to improvise, which further makes you add stuff to the prompts to reduce that.
It is much better to feed the process to the bot in pieces only when needed.
Also, when you need for example something machine readable to produce some complex item, and also something human-readable to describe the same, it often makes sense to first tell the bot to describe in human-readable prose what its evaluation or conclusion is, and then separately tell it to produce the same in a machine-readable form. Then you get the two outputs separately which your runner process combines into a conclusion.
That would be a sequential node in a behavior tree executing through the human-readable output first and then the machine-readable output.
All the #AutoGPT style agents and other processes can also be described as behavior trees. Just feed the chatbot think-command step prompts in sequence while separately managing the backend as per commands.
Plug-ins become pluggable #BehaviorTrees, which might be as simple as describing the end point and handling the related commands.
-
https://www.europesays.com/africa/229916/ Senior Dog Harness Market in Africa | Report – IndexBox #AdjustableStrapSystems #Africa #ConsumerGoodsMarketReport #DailyWalkingAssistance #ErgonomicPaddingMaterials #forecast #Lightweight&BreathableFabrics #ManagingArthritisOrHipDysplasia #MarketAnalysis #PostOperativeCare #ReflectiveSafetyFeatures #SeniorDogHarness #SupportForDegenerativeConditions
-
Aston Martin owner Lawrence Stroll hailed Adrian Newey as a bargain after announcing the star designer would be joining his Formula One team next March as managing technical partner and shareholder. https://www.japantimes.co.jp/sports/2024/09/11/more-sports/newey-aston-martin-move/ #moresports #astonmartin #honda #lawrencestroll #adriannewey #formulaone
-
"Success will often depend on what you choose to ignore.” - Futurist Jim Carroll
--
Futurist Jim Carroll is writing a series, The Art of the Infinite Pivot, based on 36 lessons from his 36 years as a solo entrepreneur, working as a nomadic worker in the global freelance economy. The series is unfolding here, and at pivot.jimcarroll.com.
--If you follow me, you will know I'm very big on not following big hype. Far too many trends are overplayed and overemphasized, and yet under-reach with unrealistic potential.
Why is that? Because I've seen over and over and over again what happens when excessively hyped trends don't become real in the short term. But here's a fun fact - I also believe the observation by Bill Gates that we tend to overestimate the impact of a trend in the short term, but underestimate it's impact its impact in the long term.
Which means timing is everything!
So let's put this conundrum into perspective. Many of us are conditioned to believe that success is about absorption. More information, more networking, more trends, more hustle leads to more success - that type of thing. But my own voyage through the global economy has taught me that the opposite is true. As the world gets louder, your success doesn't depend on what you take in. It depends on what you ruthlessly exclude.
The "Infinite Pivot" isn't just about moving toward the new; it's about knowing which 'new' to avoid, and when.
Fast-moving trends can often be a powerful distraction. The buzz they generate It is a chaotic mix of breaking news, viral hype, and the promise of quick riches. But if you jump on too soon, you'll get burned. Too late, and you'll miss the opportunity. Did I mention timing is everything?
There's also the aspect of how real any particular trend might be - and which should be ignored. The most profound shifts in my career happened when I finally built a "cognitive firewall" against trivial trends.
In an era of infinite distraction, the person who can choose what not to care about is the only one who can truly see what's coming.
Don't just filter the future.
Manage your attention.
---
Futurist Jim Carroll has developed a well-honed skill for discovering and managing hype.**#Ignore** **#Focus** **#Hype** **#Timing** **#Subtraction** **#Clarity** **#Distraction** **#Noise** **#FOMO** **#Trends** **#Attention** **#Filter** **#Pivot** **#Freelance** **#Lessons** **#Consensus** **#Quiet** **#Opportunity** **#Strategic** **#Ruthless** **#Exclusion** **#Signal** **#Gates** **#Wisdom** **#Onwards**
Original post: https://jimcarroll.com/2026/04/decoding-tomorrow-the-infinite-pivot-series-23-success-will-often-depend-on-what-you-choose-to-ignore/
-
#running
“The #NorwegianMethod is about managing load over time. Threshold-adjacent work is executed at an internal intensity high enough to drive adaptation, yet stable enough to be repeated with quality. The goal is not individual sessions that impress, but weeks that hold together”The man credited with creating this popular and highly effective system of #training has published a brilliant guide which will be of interest to #runners of all levels https://athleticsweekly.com/performance/marius-bakken-delivers-the-ultimate-guide-to-the-norwegian-method-1040011050/
-
Deshedding Brush Set Market in Germany | Report – IndexBox
This report is an independent strategic category study of the market for deshedding brush…
#Germany #DE #Europe #EU #Europa #Bondingthroughgrooming #consumergoodsmarketreport #Corrosion-resistantcoatings #desheddingbrushset #Dual-SurfaceBladeDesign #Ergonomichandledesign #forecast #Improvingpetcoathealth #Managingseasonalshedding #marketanalysis #Reducinghouseholdpethair #Self-CleaningMechanisms
https://www.europesays.com/germany/12533/ -
🎯 Understanding the #RISA Framework: Key Elements for Better Conversations
🤝 Framework developed by #BoSeo focuses on transforming disagreements into constructive dialogue
📍 #Real: Ensures discussions address genuine differences, not misunderstandings
⭐ #Important: Focuses on significant issues worth discussing
🎯 #Specific: Promotes clearly defined topics for focused problem-solving
🤲 #Aligned: Emphasizes shared objectives between parties for productive outcomes
Perfect for managing difficult conversations at family gatherings or professional settings. Framework effectiveness depends on participants' genuine interest in resolution.https://www.perplexity.ai/search/please-provide-me-with-everyth-aBSgfSsFR_qTsCYP2Eu6qw
-
So, Infix OS has been upgraded to #buildroot 2026.02 LTS well in time for our 26.03 release. We've actually been tracking it since -rc1, so this was more of a formality to rebase and rerun our regression tests. Mattias (lazzer) worked relentlessly on this, while still managing to do a ton of other things as well.
Looking forward to our next release, hopefully my BPi-R64 porting work will be done by then as well 🤩
-
Max Amini Talks Historic Madison Square Garden Debut https://www.allforgardening.com/1622985/max-amini-talks-historic-madison-square-garden-debut/ #ComedyMeansBusinessPodcast #garden #gardener #gardening #MaxAmini #StandUpComedy
-
How Max Amini Translated Social Media Power Into A Major Touring Career And A Historic Madison Square Garden Debut — Comedy Means Business Podcast
#News #Podcast #ComedyMeansBusinessPodcast #MaxAmini #StandUpComedyhttps://deadline.com/2026/02/max-amini-comedy-means-business-madison-square-garden-1236733307/
-
Earlier this week I was saddened to hear that the #FordFiesta is being retired. My first car was this 1ltr, H-Reg Mark 3. It served me well for about 5yrs, through uni, and (just about) managing to get me up the Welsh mountains!
Here's 19-yr-old me with it by Nant-y-Moch Reservoir, Ceredigion.
I'll always remember it being broken in to at 3am, and my mum shouting "I've seen you, you bastards!" out the window at the would-be thieves. Don't miss the manual choke, though.
-
My day job is all about #Python (which I love). Here are some personal rules, specific to working with Python projects:
* Do **not** install or modify global tools, especially Python itself or any packages. This means a given system might not even **have** a global Python
* Always use virtual environments (`uv` agrees with me, and doesn't need this but). I always set the global environment variable `PIP_REQUIRE_VIRTUALENV`.
* The two rules above mean my virtual environment contains (not via a link, it's really there) Python itself (and of course, of the right version)
* Virtual environments always live **inside** a project directory. Never global.
* Activate virtual environments only **inside** the project directory (`direnv` #direnv makes this easy)
* Don't install (let alone use) #Anaconda, #Miniconda, or #Mamba, because those violate all the rules above (but see the next rule)
* Anaconda-based packages implies a `pixi` #Pixi project (it's the same people, but a better answer, and you still get what you want -- the correct packages)
* No Anaconda-based packages implies a `uv` #UV project
* Always use `pyproject.toml` #pyprojecttoml over any other config file (e.g., `requirements.txt` #requirementstxt), except where things just don't work, such as needing `pyrefly.toml`
* `uv`, `pixi`, and `direnv` must exist outside of any project, so install them at the user level, or else globally if and only if that is appropriate and compelling enough to override rule oneThat was a wall of text, but in practice doing it this way is trivial. It's probably **less** work than you have been doing. This post is just about managing your Python versions, environments, and projects. Not about, e.g., using `pre-commit` #precommit, or doing type checking, etc. But if you follow these rules, your work will be easier, faster, more adaptable, and encounter fewer obstacles.
-
My day job is all about #Python (which I love). Here are some personal rules, specific to working with Python projects:
* Do **not** install or modify global tools, especially Python itself or any packages. This means a given system might not even **have** a global Python
* Always use virtual environments (`uv` agrees with me, and doesn't need this but). I always set the global environment variable `PIP_REQUIRE_VIRTUALENV`.
* The two rules above mean my virtual environment contains (not via a link, it's really there) Python itself (and of course, of the right version)
* Virtual environments always live **inside** a project directory. Never global.
* Activate virtual environments only **inside** the project directory (`direnv` #direnv makes this easy)
* Don't install (let alone use) #Anaconda, #Miniconda, or #Mamba, because those violate all the rules above (but see the next rule)
* Anaconda-based packages implies a `pixi` #Pixi project (it's the same people, but a better answer, and you still get what you want -- the correct packages)
* No Anaconda-based packages implies a `uv` #UV project
* Always use `pyproject.toml` #pyprojecttoml over any other config file (e.g., `requirements.txt` #requirementstxt), except where things just don't work, such as needing `pyrefly.toml`
* `uv`, `pixi`, and `direnv` must exist outside of any project, so install them at the user level, or else globally if and only if that is appropriate and compelling enough to override rule oneThat was a wall of text, but in practice doing it this way is trivial. It's probably **less** work than you have been doing. This post is just about managing your Python versions, environments, and projects. Not about, e.g., using `pre-commit` #precommit, or doing type checking, etc. But if you follow these rules, your work will be easier, faster, more adaptable, and encounter fewer obstacles.
-
My day job is all about #Python (which I love). Here are some personal rules, specific to working with Python projects:
* Do **not** install or modify global tools, especially Python itself or any packages. This means a given system might not even **have** a global Python
* Always use virtual environments (`uv` agrees with me, and doesn't need this but). I always set the global environment variable `PIP_REQUIRE_VIRTUALENV`.
* The two rules above mean my virtual environment contains (not via a link, it's really there) Python itself (and of course, of the right version)
* Virtual environments always live **inside** a project directory. Never global.
* Activate virtual environments only **inside** the project directory (`direnv` #direnv makes this easy)
* Don't install (let alone use) #Anaconda, #Miniconda, or #Mamba, because those violate all the rules above (but see the next rule)
* Anaconda-based packages implies a `pixi` #Pixi project (it's the same people, but a better answer, and you still get what you want -- the correct packages)
* No Anaconda-based packages implies a `uv` #UV project
* Always use `pyproject.toml` #pyprojecttoml over any other config file (e.g., `requirements.txt` #requirementstxt), except where things just don't work, such as needing `pyrefly.toml`
* `uv`, `pixi`, and `direnv` must exist outside of any project, so install them at the user level, or else globally if and only if that is appropriate and compelling enough to override rule oneThat was a wall of text, but in practice doing it this way is trivial. It's probably **less** work than you have been doing. This post is just about managing your Python versions, environments, and projects. Not about, e.g., using `pre-commit` #precommit, or doing type checking, etc. But if you follow these rules, your work will be easier, faster, more adaptable, and encounter fewer obstacles.
-
My day job is all about #Python (which I love). Here are some personal rules, specific to working with Python projects:
* Do **not** install or modify global tools, especially Python itself or any packages. This means a given system might not even **have** a global Python
* Always use virtual environments (`uv` agrees with me, and doesn't need this but). I always set the global environment variable `PIP_REQUIRE_VIRTUALENV`.
* The two rules above mean my virtual environment contains (not via a link, it's really there) Python itself (and of course, of the right version)
* Virtual environments always live **inside** a project directory. Never global.
* Activate virtual environments only **inside** the project directory (`direnv` #direnv makes this easy)
* Don't install (let alone use) #Anaconda, #Miniconda, or #Mamba, because those violate all the rules above (but see the next rule)
* Anaconda-based packages implies a `pixi` #Pixi project (it's the same people, but a better answer, and you still get what you want -- the correct packages)
* No Anaconda-based packages implies a `uv` #UV project
* Always use `pyproject.toml` #pyprojecttoml over any other config file (e.g., `requirements.txt` #requirementstxt), except where things just don't work, such as needing `pyrefly.toml`
* `uv`, `pixi`, and `direnv` must exist outside of any project, so install them at the user level, or else globally if and only if that is appropriate and compelling enough to override rule oneThat was a wall of text, but in practice doing it this way is trivial. It's probably **less** work than you have been doing. This post is just about managing your Python versions, environments, and projects. Not about, e.g., using `pre-commit` #precommit, or doing type checking, etc. But if you follow these rules, your work will be easier, faster, more adaptable, and encounter fewer obstacles.
-
My day job is all about #Python (which I love). Here are some personal rules, specific to working with Python projects:
* Do **not** install or modify global tools, especially Python itself or any packages. This means a given system might not even **have** a global Python
* Always use virtual environments (`uv` agrees with me, and doesn't need this but). I always set the global environment variable `PIP_REQUIRE_VIRTUALENV`.
* The two rules above mean my virtual environment contains (not via a link, it's really there) Python itself (and of course, of the right version)
* Virtual environments always live **inside** a project directory. Never global.
* Activate virtual environments only **inside** the project directory (`direnv` #direnv makes this easy)
* Don't install (let alone use) #Anaconda, #Miniconda, or #Mamba, because those violate all the rules above (but see the next rule)
* Anaconda-based packages implies a `pixi` #Pixi project (it's the same people, but a better answer, and you still get what you want -- the correct packages)
* No Anaconda-based packages implies a `uv` #UV project
* Always use `pyproject.toml` #pyprojecttoml over any other config file (e.g., `requirements.txt #requirementstxt), except where things just don't work, such as needing `pyrefly.toml`
* `uv`, `pixi`, and `direnv` must exist outside of any project, so install them at the user level, or else globally if and only if that is appropriate and compelling enough to override rule oneThat was a wall of text, but in practice doing it this way is trivial. It's probably **less** work than you have been doing. This post is just about managing your Python versions, environments, and projects. Not about, e.g., using `pre-commit` #precommit, or doing type checking, etc. But if you follow these rules, your work will be easier, faster, more adaptable, and encounter fewer obstacles.
-
I am really enjoying the Pixi package manager, https://pixi.sh , made by @prefix. We have been using conda at my work for managing the dependencies of our python application. It involves scientific data analysis so there are lots of dependencies, and it has been a challenge to keep things up to date. Pixi has nice support for cleanly defining the direct dependencies in the pixi.toml file, and then it automatically generates a lock file. There is a command to upgrade all the dependencies too. It's amazing! I'm just starting to use it, but it is helpful so far.
-
I am really enjoying the Pixi package manager, https://pixi.sh , made by @prefix. We have been using conda at my work for managing the dependencies of our python application. It involves scientific data analysis so there are lots of dependencies, and it has been a challenge to keep things up to date. Pixi has nice support for cleanly defining the direct dependencies in the pixi.toml file, and then it automatically generates a lock file. There is a command to upgrade all the dependencies too. It's amazing! I'm just starting to use it, but it is helpful so far.
-
I am really enjoying the Pixi package manager, https://pixi.sh , made by @prefix. We have been using conda at my work for managing the dependencies of our python application. It involves scientific data analysis so there are lots of dependencies, and it has been a challenge to keep things up to date. Pixi has nice support for cleanly defining the direct dependencies in the pixi.toml file, and then it automatically generates a lock file. There is a command to upgrade all the dependencies too. It's amazing! I'm just starting to use it, but it is helpful so far.
-
I am really enjoying the Pixi package manager, https://pixi.sh , made by @prefix. We have been using conda at my work for managing the dependencies of our python application. It involves scientific data analysis so there are lots of dependencies, and it has been a challenge to keep things up to date. Pixi has nice support for cleanly defining the direct dependencies in the pixi.toml file, and then it automatically generates a lock file. There is a command to upgrade all the dependencies too. It's amazing! I'm just starting to use it, but it is helpful so far.
-
I am really enjoying the Pixi package manager, https://pixi.sh , made by @prefix. We have been using conda at my work for managing the dependencies of our python application. It involves scientific data analysis so there are lots of dependencies, and it has been a challenge to keep things up to date. Pixi has nice support for cleanly defining the direct dependencies in the pixi.toml file, and then it automatically generates a lock file. There is a command to upgrade all the dependencies too. It's amazing! I'm just starting to use it, but it is helpful so far.