The logic of it all - User customization thoughts

Lounge
1

This is about simplicity, learning, and developing both the system and applications on it. I have been trying to develop applications by using AI. Supprisingly it worked up to a point with python coding. Unsurping it still had issues, but the outcome was rewarding enough to push this idea forward. The main problem I have come to see is not that a user is unwilling to work on something new, it is that all the information he is getting is based on willingness, if he is talking to a person, and uncertainty if he bases all his intentions in AI which can only go as far.

Getting from A to B seems to be a straighforward logic when it comes to computing. Things are expected to work because everyithing is based on a structured system. If the process is done right, then the outcome is determined. When errors happen this means that the process has faults in it. When a new problem presents itself, then things have to adapt and the whole structure needs to be remodified. This is nothing new.

I was able to create a note-taking application with voice recognition, image and sound insertion, and LLM presence, and it worked (with problems) but I got there without knowing how to code. When problems came, and they did, I just stopped because having +1500 lines of code is just too much for a beginner. What I was missing was the logic of it all. How things connect, and why. It was not my unwillingness to learn, but my expectation for something simpler, naive may it be.

So I had to re-imagine the coding process into something that makes sense to me. Things work with one another, but why it is so is not apparent to a beginner. I don’t need to re-invent the wheel, and that much is apparent. I also don’t want to spend countless hours to find answers when people have already provided them. The problem is that they don’t disclose the knowledge, and that from a point on they expect to make money from it. The internet is full of them. A countless production of sensationalist garbage for views.

Now, suppose this is a reality. A code repository, or shared knowledge base for things that work with variations that work. In this way I can custom-create anything on that proven knowledge base. No hassle, slow built-up time, maybe, but freedom is valuable and the ability not to rely on anyone for peronalization is more than valuable. The applications that work have proven themselves through user recognition of their value, but every user is unique in some sense. Mainstream applications provide value because they offer something valuable.

The thing that is missing is that the logic behind development should be clear in every step of the way. By that I mean the intention, the actual code, and the final execution. Imagine code as a chart that can be re-arranged according to what I need. If for example I want to add a block, then I have to create 4 more, and change 3 others. For this to work the logic behind everything has to be fully determined in the first place, and the logic of the changes is to be expected in a set way. This can only happen if the logic base is stuctured detailed and varied enough to have provided answers. I just want to use the answers given, and there is a whole bunch of them, but not accessible with ease at present.

Thank you all who took the time to read this post and for your patience.

2

I understand what you mean. Many beginners can generate code with AI, but when the project grows it becomes hard to understand how everything connects together.
What you are describing is actually similar to concepts like modular programming, software architecture, and sometimes block-based or component-based development.

In larger projects developers usually split the system into small modules or components, so instead of dealing with 1500 lines of code you work with smaller logical pieces.

There are also projects that try to build knowledge bases or reusable components (for example open-source libraries, frameworks, and template repositories).

AI can help generate code, but understanding the structure (modules, functions, data flow) makes it much easier to maintain or modify later.

Your idea about making the logic of development clearer for beginners is very valuable, especially if the components and their relationships are well documented.

1 Like
3

I really appreciate the idea you described about understanding the logic behind development, not just generating code. Many people today can generate code with AI, but they struggle when the project grows and becomes difficult to understand or maintain.

One concept that helped me a lot is thinking about software as layers of structure, instead of one large code file.

A common way to structure projects is something like this:

Application → Packages → Modules → Functions / Classes

This means:

  • A project can contain several applications, each responsible for a specific feature.
  • Each application can be divided into packages that group related functionality.
  • Each package contains smaller modules (Python files).
  • Each module contains functions or classes that perform a specific task.

This approach is related to well-known ideas such as:

  • Modular programming
  • Separation of concerns
  • Layered architecture
  • MVC (Model–View–Controller)
  • Clean architecture

Learning these concepts can make AI much more useful. Instead of asking AI to “build an app”, you can ask it to structure the project according to one of these architectures.

For example, you could say something like:

“Create the application using a modular architecture. Split the project into applications, packages, and modules. Each module should have a single responsibility and remain relatively small.”

This prevents the problem you mentioned with files reaching 1000+ lines.

In my own website project, I applied this approach by dividing the system into smaller applications, then splitting each application into packages, and each package into modules. Because of this structure, the longest file in my project is around 200 lines of code, which makes it much easier to read, debug, and maintain.

A simplified example of such a structure might look like this:

my_project/
│
├── apps/
│   ├── articles/
│   │   ├── models/
│   │   │   └── article_model.py
│   │   │
│   │   ├── services/
│   │   │   └── article_service.py
│   │   │
│   │   ├── views/
│   │   │   └── article_views.py
│   │   │
│   │   └── utils/
│   │       └── text_processing.py
│   │
│   ├── users/
│   │   ├── models/
│   │   │   └── user_model.py
│   │   │
│   │   ├── services/
│   │   │   └── authentication_service.py
│   │   │
│   │   └── views/
│   │       └── user_views.py
│
└── core/
    ├── database/
    │   └── connection.py
    │
    └── config/
        └── settings.py

In this structure:

  • Applications represent features (articles, users, etc.).
  • Packages group related logic (models, services, views).
  • Modules contain small, focused pieces of code.

When projects are structured this way, you rarely need to deal with massive files. Instead, you work with small, understandable pieces that connect together logically.

For beginners especially, learning how to structure a project is often more important than learning the syntax of a programming language. Once the structure is clear, everything else becomes much easier to understand and maintain.

1 Like
4

Thank you. That was very helpful indeed! What I had visualized in mind was a “commented” version of the code (in any programming language) that explains the code in a way that “helps” AI figure out the right intention and implementation according to customized prompts instead of generating confusion and garbage. I am lazy, I know that, but laziness is one step behind creativity!

In all respects your answer helped clear things out a lot!

Thank you!

5

That actually makes a lot of sense. What you’re describing is very close to the idea of well-documented and self-describing code.

Good developers often write code in a way that explains not only what the code does, but also why it exists. This is usually done through clear structure, descriptive names, and meaningful comments.

For example, comments can describe:

  • the intention of the module
  • the expected behavior
  • the inputs and outputs
  • and sometimes the reason a certain design decision was made

Something like this:

# ArticleService
# Handles the business logic for creating and retrieving articles.
# This layer separates application logic from database models.
class ArticleService:
    def create_article(self, title, content):
        # Validate the article before saving
        if not title:
            raise ValueError("Title cannot be empty")

        # Store the article in the database
        return save_article(title, content)

When code is written like this, it becomes easier for:

  • developers
  • new contributors
  • and even AI tools

to understand the inten

6

In my opinion programming using AI is possibly not productive without (at least basic) knowledge of the used programming language because you will need to inspect, correct and alter code.

These will (mostly) get clear if you know the used programming language …

… with all their bugs and errors. Again in my opinion you will need at least basic knowledge of the used programming language.

1 Like
7

Thanks for the reply.

What you say is true. I understand that. Othewise you are helpless, and learn nothing but your own ego! Things do become clearer the more I am involved. My “final” project though is simple in my mind, but difficult in execution, and unless I understand how to structure things properly, it will not work! But it is something worth both time and effort…that is unless frustration gets the best of me!

One step at a time though!

8

As already mentioned by @MesterPerfect a good habit would be to break down your project in smallest pieces (doing one thing, Keep It Short and Simple), implement them and link them together to build larger parts.
Maybe constructing the logic of your project with some kind of pseudocode would also be helpful.

9

The project I am thinking of is essentially a machine translation project, but for code to be able to run all windows programs natively on Ubuntu. The idea is simple enough. If the same hardware can install and run windows and ubuntu this means that the translation from one OS to another can be achieved with 100% efficiency. It is all a matter of proper translation.

I understand the differences in all different aspects of OS systems, ok, not entirely, but enough to see that it is complicated. Since I was an ESL teacher I also understand that translation is possible, although the languages are different. The fact that I am cetain of is that this can be achieved 100% when we are talking about OS systems as machines react to code, not natural language. If the same statement can be written in 2 different forms but the result stays the same, then the translation is successful. And it always has to be.

The answer is out there, and I believe it is achievable….somehow. Moreover I don’t think it is necessarily as complex as it appears to be, but I know nothing to back my opinio up, just instinct! What I have come to realize though is the more I look into this, the more things I understand, the more sense it makes. Maybe I am not the one to pull this through, but the process is rewarding in itself. At least so far!

10

I have been asleep while this conversation has been going on. There is a lot of reading here.

Are you people discussing what is called “vibe coding.” There are a lot of articles on the “The Register” web site about “vibe coding.” I remember one of the articles pointing out a problem with “vibe coding.”

People who become good at “vibe coding” are unable to maintain the code they have produced. Businesses are switching over to “vibe coding” and laying off people who have learned how to code and then finding out they have few, if any, employees who can fix the code that their company is using.

There is a reason why there are applications. It is so that I can use a computer usefully without having to program it myself. Unlike the early days. I learnt then that writing programs was too much hard work for my brain. Even if I was just copy typing a program printed in a computer magazine.

Regards

.P.S. I have just had a thought. This subject merits an article in the relaunched Ubuntu Wiki. User produced documentation. Just do not use an AI to write the article.

1 Like
11

Your idea is actually very interesting, and in a way it already exists in several forms.

What you are describing is not exactly “machine translation” of code, but something closer to compatibility layers or API translation. Instead of translating an entire operating system, these systems translate the Windows API calls into equivalents that Linux can understand.

A well-known example is Wine. Wine does not emulate Windows; instead, it re-implements the Windows APIs and translates the calls made by Windows programs into POSIX/Linux system calls. That is why many Windows applications can run directly on Linux without a full virtual machine.

There are also other projects built on the same idea, such as:

  • Proton (used by Steam for running Windows games on Linux)
  • ReactOS (an open-source reimplementation of Windows APIs)
  • CrossOver (a commercial product based on Wine)

The reason this problem is harder than it first appears is that Windows programs do not only rely on the CPU and hardware. They rely heavily on:

  • Windows system libraries
  • the Win32 / Win64 APIs
  • COM and other Windows-specific subsystems
  • driver models
  • registry behavior
  • graphics APIs like DirectX

So the “translation” is not just code-to-code. It is really behavior-to-behavior compatibility, which requires reproducing thousands of APIs and edge cases.

That said, your intuition about “translation” is not completely wrong. In practice, projects like Wine are essentially building a massive translation layer between two operating system ecosystems.

And your curiosity-driven approach is actually the best way to learn these systems. Many people who contribute to large open-source projects started exactly the same way: by trying to understand how things work under the hood.

Even if you never build such a system yourself, exploring the architecture behind projects like Wine or Proton can teach you a huge amount about how operating systems and software ecosystems are designed.

12

You raise a very fair point about what is now being called “vibe coding.” The concern you mentioned — that people generate code they cannot maintain — is indeed something many developers are discussing right now.

In my view, the real issue is not AI itself, but how it is used.

If someone only asks an AI to generate large amounts of code without understanding the structure behind it, then yes, they may end up with a system they cannot maintain. This is similar to what happened in the past when people copied large code snippets from the internet without understanding them.

However, AI can also be used in a different way: as a tool for assisted development, not as a replacement for understanding.

For example, if a project is structured properly — using modular design, clear architecture, and well-commented code — then both humans and AI can work with it much more effectively. In that case, AI becomes more like a productivity assistant rather than the author of an entire system.

In fact, the discussion earlier in this thread was mostly about structure and clarity in software design: dividing projects into smaller applications, packages, and modules so that no single file becomes overwhelming.

This kind of structure is precisely what helps avoid the problem you described. When code is organized into small, understandable components, it becomes easier for:

  • developers to maintain it
  • contributors to understand it
  • and even AI tools to assist with it safely

And I completely agree with your final point: one of the reasons applications exist is so that people can use computers productively without having to program them. Programming should not be a requirement for using technology.

But at the same time, tools that make programming easier — whether libraries, frameworks, or AI — can help people build useful things without having to start from zero.

So the real balance may be this:
AI can accelerate development, but clear structure, documentation, and human understanding still remain essential for long-term maintainability.

1 Like