For all intents and purposes, there is nothing wrong with using a user-friendly distro, as long as it is fairly reasonable and does not abstract the internals to a degree that are ridiculous (such as Ubuntu). The more distros try to apply their own dedicated configurations, abstractions and tools, the more they become incompatible with the base way of doing things.
Decent examples of user-friendly distros are Debian/CrunchBang, Manjaro, openSUSE (arguably) and so on. If you really want Steam that badly, check out Linux Lite, perhaps? It's Ubuntu-based, but doesn't have that much bloat or take up as many resources.
Now, as for the advanced distributions... there's five major players, three of which are in the spotlight.
First up, the one that I use and like the most, is Slackware. Going strong for 20 years now, it is the oldest actively maintained distribution in existence. The great thing about Slackware is that it is by far the most UNIX-like of all and exposes the internals of your system without any bullshit. Whereas most distros use a System V init system, Slack uses BSD-style initscripts stored in /etc/rc.d. These manage runlevels, system startup, networking, various daemons and so on. Concise and simple.
Slackware's package management system is by far the most minimalistic, and it's binary-based. Slackware packages are basically just tarballs (usually with the .tar.xz extension) with some Slack-specific metadata files and a doinst.sh for post-install config and symlink setup. They are handled locally with a set of basic utilities (installpkg, removepkg, upgradepkg, explodepkg, makepkg), although the first three are most important. There's also an ncurses-based frontend called pkgtool where the functionality of installpkg and removepkg are given a nice TUI. Remember: this is for local packages only.
Slackware has long been criticized for not having automatic dependency resolution or bleeding edge software, but that's missing the point. Slack has always had a conservative development philosophy, with focus on security, stability and having a large amount of software bundled with the installation medium itself. In fact, most things you'd need are in the DVD for you.
There is a network-based package manager called slackpkg which downloads and installs packages from various official FTP mirrors, acting as a frontend to the base package utilities, but with support for download over a network and searching.
Finally, for software that you cannot find through other means, there's something called SlackBuilds. These are special build scripts designed to set up a Slackware package which you can then install to your system using installpkg. There is a website that collects these, with each one being officially approved by Slack devs before they're uploaded, called SlackBuilds.org (or SBo). They also have a tool called sbopkg which automatically interfaces with their site, downloads SlackBuilds, runs them and even gives you the option of directly installing them.
Dependencies have to be resolved manually, but it's rarely an issue, since each package has an info file which notes these. You can make what's known as a queue file, which is a list of packages to install at once, and pipe them in. sbopkg lets you do this natively from its UI.
There's also third-party managers like slapt-get and Swaret that some Slack-based distros used, but their packages aren't necessarily stable, so I don't recommend their usage.
Slackware's installation is easy yet powerful. The only step that needs to be done from a raw command line is the disk partitioning, after which you run the dedicated setup program (an ncurses-based, menu-driven shell script) and do everything from there. You're given a lot of options and ways to manage the control flow, so you're not restricted in any way. What's really nifty is that as the system installs, you have the slack-desc (title+description file) of every package going by. Haven't seen this in any other distro.
Slackware is also the most secure by default. To do package management, you must be root. No exceptions. Sudo doesn't cut it. Some operations like dmesg, which can be done by regular users in other distros, need sudo in Slack.
It's also highly stable and uses LILO. You can set up GRUB later manually post-install, but I prefer LILO. It's so much simpler than the gargantuan monstrosity that is GRUB. Security updates are also constantly given.
In short: If you want rigid stability, vanilla packages, security, to be as close to UNIX as possible and want a bundle of software (base system-only is an option too), go for Slack. It's been tested throughout time and it's a favorite by admins and power users alike. If you're a maniac about constantly having bleeding edge software, then you'll be disappointed. But if you learn Slackware, you learn Linux.
---------------
Arch is much more recent, but it's quite popular for two reasons: bleeding edge software and system simplicity. Arch strives to provide the newest versions every single time, regardless of whether they're stable or not. Arch can potentially break a lot, and to be an Arch user you need a love of troubleshooting and tinkering.
Arch is also a rolling-release distro. Install once, pacman -Syu to have the latest system every time. Whereas Slack has a standard release model.
Arch is pretty famous for its pacman package manager. Once again, it handles binaries, but it has dependency resolution too. Arch packages are also tarballs (a PKGBUILD and some metadata). Package management is pretty similar overall, but Slack's tools are rawer and use the shell, whereas pacman is written in C.
Arch also has the AUR (Arch User Repository), consisting of a large amount of user-submitted software. Stability is not tested, but you should be fine most of the time, and it is pretty huge. There's several frontend programs for it, most commonly used is yaourt. Slack has no definitive user repository, although you can download packages from individual users at your own risk.
Finally, there's the Arch Build System (ABS), where you can download PKGBUILDs that can then be packaged with makepkg and installed with pacman. This is similar to the concept of *BSD ports trees, where everything is handled through source. However this is somewhat different, as you don't compile directly, but rather assemble packages from raw files with what's known as a fakeroot procedure. Slack has the exact same thing (SlackBuilds), except they're verified for stability (less emphasis on the ones in the -current tree, of course).
Arch also has a very lush wiki full of great documentation that is valuable for every Linux user. This is naturally owing to its much larger (and arguably zealous) community.
Arch's installation is much rawer. You're booted into a chroot environment and you set everything up from the command line. Nonetheless, a few menial tasks are still automated through the Arch Install Scripts.
Arch doesn't use initscripts like Slack, rather it uses systemd. This is a fairly new replacement for the System V init system and it is more abstracted than Slack's approach. It can generally be controlled through the userspace program systemctl.
In short: If you want the most bleeding edge and newest version of everything and are ready for things breaking, go for Arch.
-----------
Then we have Gentoo.
Gentoo is source-based, as opposed to Slack and Arch, which are binary distros. This means every package is compiled from source and can have its own particular flags (USE, CFLAGS, etc.) set for it. This means greater control over hardware optimization and exactly how you want it to be compiled, but the trade-off is for speed. However, updates may take less bandwidth.
Gentoo's package management system is named Portage, and is controlled by its frontend named emerge, which handles the actual process of compilation (ebuilds). Gentoo's system is thus the closest to *BSD ports. Worth noting is that the flexibility of Portage makes it OS-independent and it has been ported to other *nixes, even Mac OS X.
Gentoo uses the typical System V init system, but the runlevels are named rather than numbered. As opposed to Arch with systemd and Slack with BSD-style scripts.
Gentoo is also rolling-release like Arch, but it is not quite as focused on bleeding edge as Arch is, though you can get the latest through overlays and unstable repos.
Gentoo's installation process is also very minimal, but with a few quirks of its own. It requires that you compile your own kernel (though this is made easier with the built-in genkernel tool) and unload the base system and package manager (the stage3 tarball). Nonetheless, Gentoo has great documentation, so following it should be straightforward.
In short: If you want complete control over your individual package flags and to compile from source while having a reasonably stable, rolling release system, go for Gentoo. Note that there are also binaries for huge shit like Firefox and LibreOffice.
-------------------------
Fourth, there is the Sorcery family of distributions.
They're not very popular, but here's what you need to know: they're source-based, use a very peculiar yet powerful package manager called sorcery, which works on a wizard-themed allegory of handling packages (you don't install and remove packages from a repository, you cast and dispel spells from a grimoire and so on), they have a traditional release cycle.
The family of distros is as follows: Sorcerer, Lunar Linux and Source Mage. They typically offer even further control of the intricacies of individual packages than Gentoo, but are developed by small teams and consequently they aren't constantly updated due to low usage and community. Funny thing is Sorcerer came at around the same time as Gentoo and could have overtaken, but oh well.
The Sorcerer family package managers download the source code directly from the developer's website (much like SlackBuilds do), so as long as the URLs are up to date, so will the packages. Essentially rolling release but with no master repository.
However, individual package managers differ. The one I referred to above is Source Mage's, but the three distros while having common descent from one another, are mutually exclusive in their ways, with their grimoires being incompatible.
Their installation is also straightforward. Source Mage's in particular is very well made in that it's entirely command line-based, but is inside a guided environment (there are detailed instructions displayed on what exactly to do, you can switch between steps at will by typing next or prev, and see what you need to do by typing todo). Overall, it's just a slight layer on top of a Linux from Scratch system.
In short: If you want to get in the deep underground, try these one day, but I don't recommend these as a beginner due to sparse documentation and the community involvement that will likely be required from you.
-----------------------------------
In the end, there's CRUX.
CRUX is 64-bit only, source-based, uses a ports system of package management, has BSD-style initscripts and its packages are tarballs that follow a structure very close to BSD (Makefile, patches, md5sum, etc.) This is all handled through the pkgutils that CRUX uses, in particular the prt-get frontend (or pkgadd if you want more control). It's also devoted to having new software, but not to the point that Arch seeks to.
CRUX has no /usr/doc and avoids filesystem clutter.
Installation is quite straightforward and not all that difficult, but you are expected to compile your own kernel without the aid of any tools like Gentoo's genkernel.
In short: If you want a source-based Slackware and you have a 64-bit system, go for CRUX. But I still recommend you try one of the big three (Slackware, Arch, Gentoo) first to get your hands dirty and so you'll have fewer gotchas down the road.
--------------------------------
At the end of the day, you can also use a Slack-based distro like Salix, Slax or Zenwalk; Arch-based like Manjaro, ArchBang or Cinnarch; Gentoo-based like Sabayon and so on. The choice is yours.
