I'm going to describe an undesired phenomenon I recently discovered in myself, and am interested to hear whether others have found the same thing.

I'm a C++ programmer. I've used for hobby programming for a number of years, and I use it daily at work. I like the language, but that's not what I'm writing about. What I am writing about is the realization that when I encounter some difficult problem in C++, my immediate reaction is "I can implement this!". No matter how large the task, I can envision a solution and it is usually quite exciting to try to implement it.

Case in point: I once wanted to make a space game, so I started fiddling with that. Once I needed proper collision detection, I realized I didn't want to program hitboxes for every mesh, so I figured I needed to generate hitboxes from the meshes automatically. Reaction: "I can implement this!". Result: a voxelization engine which created octree's from .obj files, using them for collision detection. It worked; somewhere on my harddrive is a voxelization implementation 90% complete (there are some bugs) in a game that's about 1% complete, because after I got the voxel stuff working I got bored with the idea for the game. But I did do something cool that I learned a lot from.

In contrast:

Fast forward to today. I've gotten interested in Android, and am (re)learning Java while making a strategy wargame (which is proceeding quite nicely). But a few days ago I started thinking about loading levels. So I figured the built-in Android XML stuff should handle all that for me. Tried a bit. Nope. Then I realized that you can't spell Java without XML... well, sorta. So I looked at the Java XML API's. Groooaaan, booring. Switch to playing games. After a day or so, I look for some cut'n'paste code. Found nothing useful. Finally, today, I've started to look at the API's and am starting to make progress, but not until I had groaned about it to myself for a good while.

The observation and point:
When I work in low-level languages, I tend to take unimplemented features as a challenge and start working on them. It might not help me finish the project as a whole, but I do some cool stuff from time to time. But when I work in a high-level language and encounter the same situation, I expect the language and environment to solve it for me. When the language cannot immediately solve it in an obvious way, I get bored and start procrastinating.

Is this something others are familiar with? High-level sloth?

Programming a new system is an engaging problem solving challenge while learning an existing API is memorization and practice.

Existing API's are rarely programmed the way you want them to be and this is inherently annoying to someone accustomed to programming everything from scratch personally.

Programming a system that has the potential to be used in great ways is often more exciting than actually sitting down and going through the tedium of using something that already exists.

These issues pop up quite frequently, in my experience. It's hard to shoulder through them in a hobbyist capacity. Work is easier; you'll starve without money. Portfolio is similar: it will help you find work. Side projects that can be thrown away generally will.

I know what you mean. In my case, I was trying to figure out some efficient data structure or algorithm where I could retrieve objects based on certain criterias. For example, I'd like to get retrieve a list of Person objects whose birthday is on January, or whose first names start with a 'J', from a collection of unsorted Person objects. Then, I was like "or I could use SQL". Then off I went learning SQL. I got bored of just getting the database setup, and lost the interest.

I used to be like that, but somewhere along the line I completely inverted. Nowadays, I'm extremely lazy as a programmer. My first instinct is to make sure someone else hasn't already solved the problem in question. Granted, half the time I don't like their implementation and redo it to meet my (ridiculously high) quality standards, but it still beats doing things entirely from scratch.

I'd rather spend half a day doing something boring in a high level language and get the job done than spend a week hacking in C on Yet Another Slightly More Round Wheel. As much as I love a good low-level hack (I still run most of my debug and optimization sessions in assembly language for fuck's sake) I've just come to a point where my time is worth far more than a little bit of fun doing something by hand.

Of course, a big part of this is that I've been programming for a very long time - so there are honestly not too many low-level problems I haven't tackled (or at least know how to approach). The occasional truly new thing will still pique my interest, but usually my reaction is "meh, I've done this algorithm before with slight variations; gimme the library so I can ship the project."