One thing i did when rewriting one of my application is to write a coupe of interfaces before actually starting coding it. I dunno exactly why but this helped tremendously.

Here's an example of one of them:

class IRemotePC {
public:
        virtual void Reset() = 0;
        virtual void ProcessRemotePCMessages(MsgHeaderStruct *pMsgHeader, BYTE *pMsgData){}
        
        virtual bool InitOpenGL(){return false;}
        virtual void ShutdownOpenGL(){}
        virtual void RenderTexture(){}
        virtual void ClearScreen(){}

        virtual void WaitForScreenShotThreadToFinish(){}
};

class IRemotePCServer : public IRemotePC {
public:
        virtual void SetLoginInfo(char *pUserName, char *pPassword) = 0;
        virtual void OnLoginRequest(LoginInfoStruct *pInfo) = 0;
        virtual void SendLoginResult(LoginResults Results) = 0;
        
        virtual void OnScreenshotRequest(ScrFormat *pFormat) = 0;
        virtual void SendScreenshot(CRawBuffer *pBuffer) = 0;

        virtual void OnMouseMsg(CMouseInputMsgStruct* pMsg) = 0;
        virtual void OnKeyboardMsg(CKeyboardInputMsgStruct* pMsg) = 0;
};

class IRemotePCClient : public IRemotePC {
public:
        virtual void SendLoginRequest(char *pUserName, char *pPassword) = 0;
        virtual void OnLoginResult(LoginResultStruct* pLoginResult) = 0;
        
        virtual void SendScreenshotRequest() = 0;
        virtual void OnScreenshotMsg(MsgHeaderStruct *pMsgHeader, BYTE *pMsgData) = 0;

        virtual void SendMouseMsg(CMouseInputMsgStruct *mm) = 0;
        virtual void SendKeyboardMsg(CKeyboardInputMsgStruct *km) = 0;
};

At first the functions arguments where empty, then got filled as i was adding more code. This helped me a lot to know where i was going.

Modularity is the one word that springs to mind.

Rather than writing a load of spaghetti code and then throwing it all away, take something away from each project. A prime example - I started writing a clicker-style game the other week but I've had to scrap it now I've started work again (alongside studying for my final year it just wasn't really viable). That didn't mean the hours spent working on it have amounted to nothing - I took away a static Utilities class that did simple calculations (kind of a math library I guess), a FontManager class, a LayoutManager class (for calculating the required scaling of text/an image to fit in a certain area) and also a ButtonObject class that eventually grew to be quite large. No doubt I can use these elsewhere because they're MODULAR - any game that uses fonts can use the font manager. Any game that uses button sprites can use the ButtonObject class and any game I write (at least in 2D) can use the LayoutManager to be easily portable to multiple screen resolutions. Same for the Utilities class I guess! From my next project when I get some free time I'll probably add some extras like a resource manager, an audio manager etc..

As others have said, there's no shame in failing again and again, it's all practice and learning. Instead of beating yourself up over failing, why not look at what you took away from/learnt in the project? In reverse, why not start a project with the intention of learning? Anything that comes out of it can be seen as a bonus ;)

So the questions:

1) Modularity.
2) Hmm probably not. Your standard loop is, as you appear to know, GetInput, Process, Render (maybe you use diff. words, it doesn't matter). These steps will be different for every program, although what they do is generally the same (as their name suggests). You're touching on game engines by suggesting modularity of these components which is a whole 'nother ball park.

Hope this helps :)

lol, keep doing what your doing, in ten years, you'll be where I'm at. Hopefully a hell of a lot better though.

You'll find out eventually if you code because you love it or if your chasing a rabbit.

I got on a pathfinding kick once that lasted for 6 months. Tons of unusable code, unreadable notes. In the end I did produce something that I still implement in any game I make using path finding though, regardless of which language I use.

The moral of my little verbal toilet spackle? The majority of the stuff I have made in the past 10 years is useless, but when I look at the steps and problems I overcame getting past each point, each one is an invaluable lesson!

Keep going or get into paper mache' little doggies with 1 jelly bean inside. (<---- my backup plan)

Reading the Book "Clean Code" helped me understand how to avoid making a "big ball of mud", and creating "Technical Debt"

Big Ball of Mud - http://en.wikipedia.org/wiki/Big_ball_of_mud

Technical Debt - http://en.wikipedia.org/wiki/Technical_debt