DEV Community: Nikolaus

Building a python backend with ChatGTP - Or not.

Nikolaus — Sat, 12 Oct 2024 01:28:28 +0000

This will be a very short article - the executive summary is - don't use AI for python code. It doesn't work;

AI is very good at python coding, but it can't deal with the mess of packaging dependencies and breaking changes in bundling a real world python app.

On day 1, I had an entire app - frontend, backend, user authentication, login with Google and other OAuth providers, custom data model, and unit tests.

On day 2 I spent 6 hours trying to get the unit test to work. I thought I made some progress. But I also noticed that ChatGPT (and all the other LLMS - I tried a few) would sometimes start looping on a problem.

Looping is: GPT writes "Code 1" - run - errors - GPT fix errors with "Code 2" - errors - GPT fixes errors with "Code 1" - .... infinite loop of going back and forth between two code bases.

On day 3 I decided to get really into it and understand all the code so I could fix it up - reading documentation on the various clever ORM wrappers, packages, and so on. The unit tests almost started working, but then never really did.

Day 4 I decided I will actually write all this from scratch - building something minimal that works, then building on top of that, just like you normally would.

Why is ChatGPT failing so badly at Python? The reason is that GPT can't deal with Python's main problem - the package manager, breaking change versions of both Python and available packages.

The AI writes very nice, functional, correct Python code, and can explain it very well if needed; but it can't deal with a package that was upgraded to suddenly have a completely different API. With an ORM wrapper that can do things in a variety of different ways.

So something that should take 2 minutes, like "please just give me a backend with user authentication" takes 5 days or in my case, never even gets done as the AI loops between non-working solutions.

Lessons learned!

Perhaps understanding what you're doing is not as dead yet as some of us thought. It's still relevant in 2024.

Generosity, Abundance, and What Do We Want

Nikolaus — Sun, 26 Jul 2020 16:11:04 +0000

Fresh from the Seeds Labs

Seeds is a regenerative currency designed to create a better world.

It was born out of a question: What if, instead of incentivizing destructive behaviors, a financial system rewarded regenerative behaviors?

And so Seeds rewards its citizens for playing and being a part of the regeneration of the planet, there are rewards for reputation built over time, there are proposals for common good projects, weighed voting, and many more features. It's owned by all, completely decentralized, and all of the rules can be changed by the citizens.

All in all the Seeds constitution and rule book is over 100 pages long - I love it.

But recently we've been discussing new modes of payments which I envision to be at the basis of the world we actually want to build. The goal of Seeds - from my perspective - is to make all currencies obsolete, and to provide the actualization of a roadmap whereby we move from scarcity to abundance.

What Do We Want?

As a society, a collective, and a humanity, we want to enable heaven on earth here in the physical, on our planet.

Earth is abundant - we have everything we need already. So the job of Seeds is not too difficult. The abundance needs to just be unlocked and freed from the systems that are seeking to limit it.

Our past systems are based on survival/fear and power/control - and so we need to create all new systems. Better systems. Seeds doesn't solve all problems for all people, but it has a place as building a better financial system.

If we all live in more beautiful, fair, and equitable systems, then we all live closer to the truth of reality, where we are all united, all one, living connection and joy.

Donations - Giving based exchanges

I see our financial exchanges ultimately moving to a system of synchronicity - where everyone does what they want, and everything gets done.

Halfway there is donations, and giving based economies. Where a service or good is provided on a donation basis, or a sliding scale, or a variation thereof. Many healers already work this way because it is the closest to God.

Donations can move us from a society based on taking to one based on giving.

Generosity and Abundance Tokens

Deep in the Seeds labs, we are thinking about abundance and generosity tokens.

We want to support donations in the best way possible and so the idea is to gamify donations by giving out special abundance or generosity tokens. Those who pay more than was asked, receive abundance tokens in return. They could also be NFTs (Non-fungible tokens) and badges - and these are not tradeable they're more a measure of the level of abundance a Seeds citizen represents.

They won't be directly worth money - that would defeat the purpose - but they will be publicly visible on an account, and verifiable too - there's no way to cheat. The only way to gain more abundance tokens is to pay more than was asked! Verified on chain. Or for open donations, they would be given out for donating more than the median donation.

Seeds has a built in reputation score which does influence a citizens share of the harvest as well as vote power - reputation is an important part of the system, both to reward integrity, to signal others that an account is trustworthy, and to eliminate bots and scams.

But the abundance tokens would only very indirectly influence a Seeds holder's scores - they are visible and so others may be more inclined to transact with them, but that's it.

It's a thought experiment so all comments, ideas, and criticisms are welcome on the Seeds Community Telegram channel here: https://t.me/SEEDS_Community

Onwards, humans!

Is One Source of Truth just a fancy name for Global Variables?

Nikolaus — Fri, 16 Nov 2018 03:43:55 +0000

I've created very large scale and extremely robust applications using object oriented programming. OO is a good way to modularize code and insulate it from other code, so things stay inside their design.

Now I am working on a React Native app, and while the view system is really good, the global state thing puzzles me.

[Naive] opinions:

One source of truth philosophy is just global variables.
The problems that redux and mobx solve are ingenious ways of dealing with the limitations of web development. These problems do not exist in native OO programming and the solutions to them are therefore irrelevant.

These are statements to discuss - I'd particularly like to hear counterpoints. I want it to make sense! I am happy to change my opinions if more aligned ones come along. As Groucho Marx said "I have my principles, and if you don't like them I have others!"

One source of truth seems to be the discovery, by web programmers, of global variables. Global variables are known to make code error prone, brittle, hard to debug, hard to maintain, and generally make a mess of things. If you want to get fired on your first day of the job as an OO programmer, introduce a bunch of static globals into the code base.

I understand why this happened - web programming has its own set of constraints thanks to a runtime environment that was never designed for apps, yet is used for apps. So these things had to be created to deal with it, and to get anything done. It's an amazingly elaborate and innovative way to get around these constraints.

But now it's creeping back into native development in React Native. The vast majority of problems that are solved by redux and mobx don't exist in native apps. What remains is a global state management system.

In any OO program I've worked on, we could have done that. We could have created a God-State object, and run all state through it.

The reason nobody would ever do that is that it's a very poor design. It won't stand the test of time, it'll be buggy, it'll require every coder to know everything about every corner of the application, and all the other reasons we do not use global variables.

You do not want one massive, complex object where changes to it could potentially break any part of your app. It's the last thing you want and it's the reason why first modular and later object oriented programming were invented to begin with.