u/Still_Explorer

Usually how you would hire an artist goes like this:

. You seek portfolios (social media, X, YouTube, Deviant Art, ArtStation, PolyCount) (Probably there's a chance to find nice artists on assets stores, like Unity Unreal or BOOTH, though those products are sold en masse but at least you can spot profiles and contact information if needed).

. You seek some pieces of work that are closer to your project (if you are seeking stylish cartoon style then looking at realistic sci-fi or dark horror makes no sense _ this is why portfolios help you to navigate your way through selecting not just an no-AI proof).

. Probably it depends, you might find experimenters or fiddlers (technical artists) on social media like X and this is definitely proof of no-AI, however then the point would be if you can gain something from this.

Someone might make cool swords, someone might be good at texture painting, someone might get the faces perfectly, someone might be designing cool clothes and unique character concepts. Unfortunately it takes a lot of time to discover talent you like but it is something of great importance. You might be able to allocate small and focused tasks where needed and getting lots of small great results than getting one and ambiguous result. (eg: one who is great at characters, might miss the extreme and  original outfits - that is a matter of specialization).

Some like this.

Command: Try to kick the wall and search for a loose brick. (Always worked for me in text adventures).

Forgot to include the three laws of robotics during training. Now it's too late.

Cybergladiator 2: The Benchmark Seeker

That dance looks fabulous! ✨

PLAY BALL!

Screak Fighter 2

Ratyu Wins

Is like school projects, where the most diligent and studious kids did all the work, and the rest would be loafing around and get free marks. 👌

The point is not if you use AI to write automatically thousands of tests cases and ensure the validity of the software. (The boring and severe time consuming tasks that no programmer has the time to do).

The point is if you use AI to make a cube-clicker game, then it means you're in trouble...

At first I was Battman.
Then I was Ironman.

What I figured out (also while battling against code perfection OCD) was that once I spent a ridiculous amount of time trying to make code as perfect as possibly could.

With very clear modules, top-notch design patterns and also a great event-driven.

Then what really happened was that, after one week I could not navigate the codebase at all because it was too complex, I had to test-validate the program dozens of times and change things, finding unexpected edge cases (getting dumbfounded) forcing me to rewrite huge chunks of the program about 3-4 times. Everything while struggling to navigate the complex codebase.

At some point I got mad with this 😂 and did a fast rewrite of the entire thing in 3 hours, everything procedural (only structs and functions), in only one file of 700 lines. And I might say that it was so good that I kept it like this ever since.

The great lesson here was that typically you have some level of programming experience and know a few things here and there. However the actual program (the requirements, the edge cases, the validations, the testing) has not been figured out yet. So in this sense you surely know how to write the code (convert thinking to code) but you might be entirely clueless about how the problem is supposed to be solved in the most efficient way as possible and also being able to manage the most critical edge cases.

So the bottom line is that (what someone else said - I read that from) that only once you rewrite your program 4 times you will be much more knowledgeable and the code would have been perfected 4x times.

This also means that if you have written 3 games earlier, the 4th game is supposed not to include the mistakes and problems of the earlier, it might be more improved and so on.
Or in another sense, if you have written 10 games, the 11th game would be created automatically with eyes closed, because your 9th game was supposed be better than the 8th and so on.

Is a continuous process of learning.

When you do an InitWindow, then an "InitPlatform" is called (that does GLFW window creation). Then the part responsible for flags is "SetWindowState" this one might have it.

https://github.com/raysan5/raylib/blob/master/src/platforms/rcore_desktop_glfw.c#L372

I haven't tried this yet, but what I've seen is that is feasible to destroy the window and then create it from scratch.

One problem with it however is that it needs to be do a main function restart. Not having to close the application and boot again, just having the main function destroy window and if it has a restart boolean to do a goto to the start of the main function.

As for example if you consider a very typical game, how would be initialized:
- load command line args
- load configurations from file
- initialize engine and other systems
- load the level, populate lists of entities
- setup main variables and other values
- enter main loop and update all application logic and entities

Each one of those items mentioned, is literally an entirely new module/system on it's own. Such as "parsing arguments" or "reading config files" or "math utilities" or "loading the level". Each of the other systems (loading assets, init renderer, init audio player) are their own modules doing their own things as well.

So is easy to see here that even if you don't want to modularize a program (and drop everything in the main) that naturally, based on the types of different tasks and work getting done, that immediately you start thinking in modules even if you don't want to.

Even if for example you don't want any modules in your code, entirely accidentally and habitually you might start to group things together, math utils go together, drawing things go together etc... Then is only a matter to define the boundaries of the module and organize things.

Served!

Typically when I would start something new that I would be unfamiliar and inexperienced in, I would seek project references on GitHub.

Having some reference as a foundation is like having some ground truth and will allow you to remain steady and sure about where you're going and what you're doing.

If for example you start getting seconds thoughts and questioning things more than needed, then the project reference can clear things up by showing you what worked before for someone and by great percentage would work the same for you.

Though it makes sense that you will use some parts from reference but also improvise other parts, so is not that you would be constantly sticking to what already exists. However the idea is that once about the 60% to 70% is well established and known, only the rest few parts would be unknown and you would have to improvise there.

This makes things more predictable and organized, rather that you would normally go 100% by random chance. 

I have switched project categories every couple of months, from 3D engines to compilers, then to various utilities, to games, etc. So is not odd to say that when something gets boring to drop it and move to something else.

However when it comes to 3D engines, what is the ultimate goal?

Having a project as reference in mind (a game, or a 3D application etc) and then trying to experiment and gain knowledge and experience about how the backend parts are supposed to be created and connect.

As for example if you don't have a project goal at the very far end, a very long term goal, then definitely the problem would be that would be unable to connect the "right now" to the "future then" parts. As for example even if you have something very simple in mind, such as understanding how Quake1 engine works, or even how a big engine like Unreal works, is far better than having no goal at all, other than like saying "I like games > I want to make an engine > then what".

Also one very simple thing, is to think about thinking in very realistic ways about what is feasible and what not, at the exact level experience you are in. Beginning something is correct and expected to do simple things that work and they are easy to understand, the meaning is to find the balance between productivity/expertise and gain positive progress experience.

What many beginners usually do (since the dawn of time) is that they try to make the most advanced and difficult things and usually leads to very bitter mental experiences. Challenging and difficult projects are great because they allow you to actually advance your skills, but there should be an objective understanding that when something is difficult means that getting stuck in only one part for several months is part of the job, and keep working on something for several years is well expected.

However another good thing is that there's another aspect about *learning how to do something* and another one about *utilizing something existing that works* so in this sense, you might be able to do some simple and basic tutorials to learn something and get more knowledgeable, but then if you actually do not feel that you need to go up to the far end with it (eg: do vertical integration = where you create every toolset by yourself for yourself). You can use something else that exists and does work the way you like and is maintained by dozens of other people, in this aspect you can join any open source project you are interested in and start filling in the blanks based on what you learn and how you use the library.

[ As for example even the greatest company, Rockstar, initially created GTA3/Vice/SA using another closed source graphics engine -RenderWare- that was created by another studio. It was only after the RenderWare engine got sold to a competitor, that they realized they needed their own engine in preparation for GTA4 and so on. ]

Find a reference project (whatever it is, eg: pong, asteroids, backgammon) and study everything in it.

If you can replicate and understand something like this then you might be able to figure out how to create your thing.

Provided however that your design won't be entirely different from the source, then you will need new references that will be closer to the new thing you are making.

For me the case was somewhat opposite, I didn't want to learn CMake and didn't learn it. I just copied lines from dozens of other cmake scripts and brute forced it until it worked. Now also I am not sure I know CMake but I know about how 20 or something commands work and I use them.

And somehow this goes for all sorts of programming or even third party libraries. You don't need to be an expert in 3D physics - you just use Box3D. You don't need to be an expert in databases - you just use SQLite. You don't need to be an expert in networking - you just use libhttp.

In terms of educational purposes, learning is free and unlimited, someone can learn everything and anything within 90 years. But the real catch in everything at some point is to define exactly where your area of expertise is and be concerned only with problems related to that area, for better worse then, using libraries made by other experts (who have mastered their respective areas) is essential.

Is like if someone is dropped in the middle of the ocean, and see a life jacket and a box containing a satellite phone and say "F this S man I am throwing it away! I can make my own open source satellite phone with Raspberry once I get home".

Problem is not about making your own thing, but problem is not using something that works when you need it the most.

That's awesome. Very good idea to work with anything that suits the needs of a project.

l

Also would be great idea to port to a cross platform GUI so is easy to use anywhere. 👍

No other better than egui https://www.egui.rs/

Its the N-icon.

Something I tell to others all the time, is by having a look at published job postings. And then depending on level of requirements to see where can you apply for better chances.

As for example probably with C or C++ there would be more prerequisites (such as practical project experience or in many ways - experience with the Linux ecosystem).

However for webdev typically it would be somehow "easier" to get in. Such as PHP is very popular choice because typically used in all sorts of general purpose webdev, but C#NET or Java might be more specialized due to the state of the companies using them (eg banks or enterprises).

However if you unsure what to do, you can try some bootcamps or seminars in some class near your city. At least you would be getting some experience from it and probably some contacts to connect.

That's bad man, because you indeed knew how to solve it.

A great technique would've been to write it  in Python first because is very quick to turn thinking to code instantly. Then porting to C and such.

Though don't give up, because there would be many other internships near you. Also how things go right now in the job market, don't be shocked if you send  a dozen of  CVs and get no reply.

AI takeover is an entirely new topic to worry about, as seen in r/ProgrammingQuestions 

Was it a matter of some specific problem solving technique (algorithm?) or it was about the experience and gotchas of C that is very technical and needs special approach to implement things?

Now for example if you gained more knowledge on the problem (eg asking ai), can you see what the solution would've been?  

I find it very reasonable that facing a problem the first time you might miss something or approach it with a very clumsy way. The only thing that does matter is more experience.

Though it makes sense that not knowing something is a bummer, but from what I figured out, the first 10 years in programming is about getting dumbfounded constantly by entering uncharted territories all the time.

Hey bro, get away!
You can't lie-on here.