
The Imposter's Handbook - isp
https://impostershandbook.com/
======
eksemplar
I have a degree in CS and I've never found myself in a situation where anyone
would discuss bouble sort vs merge sort. Neither have I been in a situation
where big-o was relevant beyond the basic concept of not doing obviously
stupid shit.

What you've really missed is things like best practices, design patterns and
concepts like SOLID, but a lot of people with CS degrees missed some of those
as well.

If the book covers this, excellent, but why wouldn't it sell itself on valid
points?

~~~
jacobsenscott
I have a CS degree, and while nobody sits around talking about data structures
and complexity that's not the point. It gives you a foundation of knowledge
that you automatically and subconsciously apply to every job you do.

A CS degree prevent you from making a lot of obvious (if you have a CS degree)
and costly mistakes. It sort of gives you a crystal ball. You can see that
some code isn't going to work when a db table gets to 100,000 records, or that
some code is making the wrong space/time tradeoff, or that some code is using
the wrong data structure from the standard library.

When your performance monitoring tool is telling you something is slow or
leaking memory you have the foundational knowledge to understand why and fix
it, rather than spending money on 10 more dynos or whatever.

Computers are so fast and cheap today a lot of this doesn't matter most of the
time. The naive solution does just fine. But when the core dump hits the fan
you better have one or two CS grads on staff.

~~~
BinaryIdiot
> A CS degree prevent you from making a lot of obvious (if you have a CS
> degree) and costly mistakes.

I couldn't disagree more. I do not have a CS degree and have lead many teams
of folks with a combination of having and not having them. It's a huge mixed
bag and I'm not confident you can make a general statement in _either_
direction.

Yes CS can prepare you by knowing some of the basics but I've run into
countless people with CS degrees who don't understand how much of anything
works. I've also run into many without CS degrees who understand how the damn
storage implementation in Postgres works.

Anecdotally, to me with my small bag of data points from the teams I've lead
and the people I've interviewed, a CS degree is only what you make of it. If
you were a good student, studied and understood the content then you have an
edge. If you were an okay student who just memorized things for tests and
never actually applied the knowledge then you're in no better state than
someone without a CS degree (perhaps even in a worse state as most of the
people I know, including myself, were told by _multiple_ leads that without a
CS degree everything is going to be a struggle and to advance you career you
must get one so of course I had to work even harder to prove them wrong).

~~~
nikmobi
I agree with you for the most part, but I think if his sentence read:

> A CS degree _can_ prevent you from making a lot of obvious (if you have a CS
> degree) and costly mistakes.

I think most people can agree that it doesn't provide any guarantee, but it
definitely gives you a boost in the right direction.

(For the record, I don't have a CS degree)

~~~
BinaryIdiot
Yeah a simple word and I would have taken the post entirely differently :)

~~~
jacobsenscott
I must have thought the word 'can' and didn't type it because it doesn't read
right as it is. I do that sometimes.

~~~
BinaryIdiot
Fair enough. I to do that quite frequently :)

------
drak3
The excerpt on the Boolean Satisfiability Problem reads

> The basic concept that people have figured out, so far, is that a number of
> NP-complete problems can likely be solved if we crack the Boolean
> Satisfiability problem.

And

> If NP-Complete problems get resolved, it is likely (though nobody knows for
> sure) that we'll crack every NP-Problem

Isn't the definition of a NP-Complete problem exactly that it is in NP _and_
every other problem in NP can be reduced to it in polynomial time. So we know
_for sure_ ([Cook71]), that as soon we have a polynomial algorithm for SAT
_every_ problem in NP can be solved in polynomial time, and not just some of
them as the excerpt claims.

Am I missing something? Because this seems like a very confusing, if not
downright wrong, way to explain NP-completeness and its link to SAT.

[Cook71] Cook, S.A. (1971). "The complexity of theorem proving procedures".
Proceedings, Third Annual ACM Symposium on the Theory of Computing, ACM, New
York. pp. 151–158.

~~~
acs5
Also, the description of the boolean satisfiability problem isn't the boolean
satisfiability problem at all, but just what we might call the boolean
evaluation problem, or a version of the circuit value problem, which is
certainly in P.

I have no idea what's going on in the lambda calculus excerpt further down the
page, in particular substituting (λx.x x) with (x x)? There seems to be a
fairly big misunderstanding here. And lambda calculus isn't reduced in any
particular order -- there are many ways to reduce the same term.

~~~
tom_mellior
I was going to post the same thing about satisfiability. The excerpt about the
Y combinator is also misleading. There is no practical way in which the Y
combinator "finds the fixed point of any function"; (Y cos) certainly does not
magically evaluate to 0.793085.

I think books like this are a good idea, and having self-taught people write
them is also a good idea. BUT it looks like this particular book is in serious
need of quality control.

(Also it should be split up into several parts. Any book that teaches both the
Y combinator and how to configure zsh is... weird.)

------
apeace
I have a funny anecdote about CS.

I am a CS dropout who has been working in startups for a few years. About once
a year, I see another programmer making a common mistake, and I draw on my CS
knowledge to help them out.

The mistake is parsing HTML with regular expressions. It is so tempting to
write a good ole' regex to grab that attribute value off of that element. And
it works on the 5-6 samples you write your unit tests with. If you have run
into this before, you may know that zalgo[0] tends to appear in this
situation. Parsing HTML with a regex will always fail eventually.

Of course the reason is that HTML is not a regular language. It is a context-
free grammar, and thus requires a parser to parse it.

The funny part is, I failed CS Theory once, and was in the middle of taking it
again when I decided to drop out. But this tidbit of knowledge has always
stuck with me, and I've used it again and again to fix or prevent bugs in real
software.

Takeaway: CS knowledge does have real-world value to everyday programming. You
just have to know what you're looking for. And of course, always use an HTML
parser to parse HTML.

(I'll add one more note to anticipate a common response. If you look at any
HTML parser, you _will_ see regular expressions in the code. These regex are
used for _chunking_ the HTML, and from that point the chunks are _parsed_.)

[0] [https://stackoverflow.com/questions/1732348/regex-match-
open...](https://stackoverflow.com/questions/1732348/regex-match-open-tags-
except-xhtml-self-contained-tags)

EDIT: Formatting

~~~
legulere
I think the HTML/XML/JSON is not a regular language story is a bad one,
because subsets of them are indeed regular. Most of the time the data you're
trying to parse doesn't contain arbitrarily deep nesting and could actually be
parsed with a regex. Further regexes of languages like perl can parse a
superset of regular languages.

The real problem with regexes is that they are hard to maintain and are
extremely hard to get right to neither have false positives nor false
negatives.

~~~
ultramancool
This is one I've never quite understood. Having written many scrapers I will
say - Scraping is always hard to maintain. I've written regex and parser based
scrapers many times, but it's still a need for constant updates as the page
changes.

HTML will change about as often (only slightly less in my experiences) than
regexes will need to be changed and can take more time to test and develop on
each update, especially if you don't have access to a very durable parser
which can stand broken HTML, unlike most XML parsers. So if a regex does the
job, use it IMO.

------
anexprogrammer
The main thing people miss out on not having a degree is not getting past
silly HR "must have degree" filtration.

Never once found a CS degree a worthwhile indicator of ability.

It may be a superb book, but not even giving a sample chapter out to judge
writing style, quality of explanations, depth and so on?

~~~
continuational
Comments like these can only really have two causes:

\- You've bought into the anti-intellectualism wave that's going on in the US.

\- The universities near you are really poor.

Is it really the case that you learn so little on these universities that you
literally have no advantage over those who didn't attend?

~~~
noobiemcfoob
I think it's more many people vastly underestimate just how much they and
others got out of their education.

Sure,everything is a bell curve, but spending the majority of your time
thinking of little else beyond software concepts for 4ish years _will
fundamentally change_ how you think and reason.

~~~
collyw
I learned a lot in my time at university, but to be fair it was just a
starting point and I have learned a lot more by myself afterwards.

------
isp
Via patio11's tweet: "Pretty brilliant idea: 'Imposter Handbook', for teaching
self-taught devs what they missed by not doing a CS degree." \-
[https://twitter.com/patio11/status/767204505578409984](https://twitter.com/patio11/status/767204505578409984)
(with replies)

------
squeaky-clean
I'm always pretty skeptical of anything that offers "Learn X Quick!". Is there
any reason I should trust the author of this as a good source? They even state
they only started learning this stuff a year ago. I wouldn't take a course or
buy a book from anyone claiming only 1 year's study in any subject, why should
CS be any different?

edit: It's also hard to find the author's name to find out who they are. It's
not in text anywhere on the page, only in the image of the book cover.

~~~
ruraljuror
Agreed, it is hard to find the author's name. I noticed that it was by Rob
Conery in one of the blurbs and that turned my skepticism to interest as I am
familiar with Rob as a frequent guest and collaborator with Scott Hanselman.

As a self-taught programmer (English/Classics major), I am (or was) the target
audience for this book, but with deliberation have returned to school
(ultimately pursuing a master's in Computer Engineering).

------
haddr
Yep, people are really forgetting that most of the time it's just being clever
rather than having (or using) in-depth knowledge is what allows to bring some
good solution to the table.

An example from today: we have a very slow pattern matching code, that starts
to be a bottleneck for the application. What can you consider? Well you can
dive into sexy bloom filters, experiment with some Trie-based structures. But
then when you analyse the problem it results that simple word lookup with a
simple hashtable is the fastest solution for given constraints. No big deal,
no rocket science.

Probably the same goes for rocket scientists, but one level higher ;)

~~~
pc86
Seven or eight levels, I would imagine.

------
scaleout1
when I was college I thought all the data structure and algorithm courses were
complete waste of time. Primarily because I was working as an intern on the
side, making crud applications, slinging xml, writing DAOs etc.

For first five years of my career I never had to touch any of the stuff I
learned in school and I was particuarly happy that I mostly mailed it in in
those classes. Eventually my career evovled into dealing with data at massive
scale and working on some of biggest services on the planet and the way I have
taught myself to program completely changed. No longer it was possible to just
sling code and hope that it will just scale to million of users. All the stuff
that I slept around in class was relevant again and I had to go back to
coursera and take those classes all over again. So moral of story, if you will
be slinging webapps rest of your life you probably dont need to know Big O,
different search algo, linear algebra and statistics etc but if you think you
will be working on stuff thats coming around like automanous cars, IoT,
augmented reality etc, you should definitely read up on it

------
jasonjei
I think one of things that "millennial" self-taught programmers have trouble
understanding is OS. While the need to implement OS functionality is now a
niche (like process scheduling), I have noticed that "millennial" self-taught
programmers have gaps in knowledge with respect to threading, mutex/semaphore,
consumer-producer pattern, synchronization vs. lock-free (blocking vs. non-
blocking), concurrency and parallelism. I still feel these are essential
topics to understand since these issues often come up in most programming
languages (JS, Ruby, Go, etc). When deciding between Nginx or Apache, for
example, knowing the difference in philosophy is useful (asynchronous vs.
thread-based). One of things that CS trained me very hard was to think about
cost; when I programmed before my CS education, the old adage of everything
looking like a hammer was particularly true for me. Also, many of the self-
taught guys need to use fewer libraries/gems and more stdlib and primitives
because every additional include is not always necessary and may unnecessarily
increase complexity :)

Pipelining is another concept that I feel self-taught programmers have weaker
foundations--many of whom I have worked with write code that waits for all
results to become available, while an operation that's blocked by I/O doesn't
necessarily mean we can't do stuff with the CPU while we're waiting for the
next batch of I/O to come through.

I have also seen self-taught programmers accidentally write O(n!) or O(2* * n)
functions and not realize it. I think data structures is definitely a good
chapter to have. Especially when writing queries to a data store.

I think explaining how a hash table works would be excellent since it is such
a useful and fast data structure. A lot of set-taught programmers sort of
treat them like magical black boxes when it's not a very complex data
structure yet it's practically O(1) for most insertion/reads/deletions.

Memory management is fortunately something we don't really need to worry as
much about. With languages and interpreters that do a very good job of
cleaning up after our code and now that memory is relatively cheap, we can
afford to ignore it until we need to scale.

Of course, if you have a good product, you can get away with inefficiency and
hire CS guys when you have built a unicorn. ;)

~~~
nspriego
Just curious, why the "millennial" descriptor? Is having trouble understanding
the OS something unique to only "millennial" self-taught programmers?

~~~
Ensorceled
In my experience, Gen X and Boomer self taught programmers spent a lot of time
hacking at the application or system level and have less holes in that area.
They have other holes in their knowledge base, just not those ones.

~~~
jasonjei
That's exactly the reason I chose that descriptor. In fact, the field
"Computer Science" may not have existed before.

------
fitzwatermellow
As an alternative, I would recommend something like Michael Kerrisk's _The
Linux Programming Interface_ in lieu of a survey of foundational CS. Gaining a
deep understanding of memory, files, processes, threads, signals, sockets,
etc. As well as strong Emacs-Fu and bash scripting ability. These are the
first steps on the path to mastery ;)

~~~
riskable
What's interesting is that what you're talking about is _computing_
fundamentals. Stuff that kids should be learning about in high school _before_
they go to college. At the very least they should teach kids what happens when
they type a character in a text editor and then save that as a file. Kids
should know that the key switch state change gets detected by the keyboard
hardware, sent as a signal over the wire, detected/handled by the
OS/kernel/driver, sent to the program as an actual keystroke which decides to
"display" it to the user by updating the interface, etc etc.

Discussions surrounding what happens when two programs try to write to the
same file. How to detect when a file changes. Stuff like that. These things
just don't seem to come up in high school education and I can't help but
wonder why. It'd go a long way to giving people explanations as to what's
wrong with their computer when it's running slow or a basic means of
interpreting error messages/conditions.

------
anoother
Proofreading error near the 'buy' button.

> I've learned more in this last year since I started programming over 25
> years ago.

Should be '... this last year _than_ since ...'

Personally, I think '... th _e p_ ast year _than_ since ...' reads better
also.

Do I get a free copy of the book for pointing that out? ;)

~~~
mkchandler
There is a repo for posting feedback (such as proofreading errors) here:
[https://github.com/imposters-
handbook/feedback/issues](https://github.com/imposters-
handbook/feedback/issues)

------
bogomipz
I am curious, do people actually pay $30 for an ebook without even being able
to see a(propsed) table of contents of a sample of the writing?

This is unusua. With both Amazon and LeanPub you can at least gauge the
writer's style or get a feel for writing quality by looking at a sample
chapter and a table of contents.

I'm skeptical that all of those people praising the book bought the book site
unseen.

~~~
ljk
apparently this is the ToC for "pre-release #2"
[http://i.imgur.com/ssYr5ki.png](http://i.imgur.com/ssYr5ki.png)

seems like pretty simple stuff; couldn't all the information be found with one
internet search away?

~~~
bogomipz
Couldn't the table of contents be available on the official site for the book?

I should instead resort to doing a separate Google search for the TOC?

------
cookiecaper
This thread is long and this will probably get buried, but I'll leave it here
anyway. I'm really excited about this kind of thing and have sometimes thought
of writing one myself, primarily as a means for me to hammer out all the
theoretical areas that are still foggy for me as an autodidact. If this can
make it easy to pass impractical textbook-style interview questions and give a
good, reliable foundation of CS knowledge that won't go away ten seconds after
closing the Wikipedia page, I'd _love_ to buy it (and I still may write my own
some day just for good measure :P). I think autodidact programmers is a
rapidly-growing and under-served market (though, unfortunately, I don't think
it'll be allowed to go on much longer; I expect professional licensing
organizations similar to the ABA to show up on the horizon soon).

~~~
pjc50
I like the approach of hammering out knowledge through writing it down. I
taught myself to fill in a lot of knowledge gaps by _answering_ questions on
electronics.stackexchange.

------
brians
The example text about the y combinator looks mistaken to me. It says Y can
"find" a fixpoint, and sketches an example of a fixpoint in a numerical
function. It implies Y is doing something like convergence.

But that's not what Y is at all. It's called the fix point combinator, yes,
but with the assumption you're going to use it in some curried lazy evaluation
scheme with higher order functions.

All this on ycombinator.com, too!

------
LeonM
Anyone knows if there will be a hardcopy available? I live a paper free live,
except for books, I just hate reading from a screen...

~~~
gagagababa
From the "Questions" section:

Will there be a print version?

That's my goal, yes. I want to be sure all the edits are made and,
technically-speaking, the book is completed. If I do end up with a paper
edition, I'll send out a note to the mailing list in late September, early
October.

edit: Formatting.

~~~
LeonM
Thanks, I missed that because apparently the site only loaded half on my
browser, it's probably being hugged to death right now...

------
RawData
What programming language is generally used throughout the book?

~~~
internals
C# & Javascript/Node. You can find the sample code from projects in the book
here: [https://github.com/imposters-handbook/sample-
code/](https://github.com/imposters-handbook/sample-code/)

~~~
ManlyBread
For C# I recently found this course, looks pretty good:
[http://www.brpreiss.com/books/opus6/html/page10.html](http://www.brpreiss.com/books/opus6/html/page10.html)

------
Jayakumark
He also wrote another book [http://www.redfour.io/](http://www.redfour.io/)
take off with elixir. Anyone have read that ?

~~~
cheeseprocedure
I went through the video version. I found it worthwhile overall, but grew
frustrated later in the tutorial as the code displayed in the video (and in
the associated GitHub repo) drifted substantially from what it had actually
been guiding me to build.

~~~
Jayakumark
Thanks, will wait for final release, by then i guess the code should sync up
with video.

------
outworlder
Is there a book like this for Calculus? My CS is fine, but I had horrible
Calculus teachers and was unable to cross the chasm myself.

~~~
camel_Snake
Honestly the best resource is probably Khan Academy.

------
awkward_yeti
Where is the ToC ?

~~~
internals
I didn't find it online either, but did just pick up the book. This is ToC of
pre-release #2 (~500 pages):
[http://i.imgur.com/ssYr5ki.png](http://i.imgur.com/ssYr5ki.png)

------
tomc1985
This looks interesting but I got turned off by the site design -- there are
too many self-help "gurus" out there who make promo materials that look just
like this. Quotes on a book that isn't out yet, while plausible, is really
kind of weird.

------
fastball
For anyone that thought their background image looked familiar.

[http://www.jpl.nasa.gov/visions-of-the-
future/](http://www.jpl.nasa.gov/visions-of-the-future/)

------
mgrennan
I think I'll buy a copy for all the BRO-Grammers in my office.

~~~
am8
Idiotic arrogance

------
gd2
First I've heard of this book, but catchy title.

------
roadman
CS for Dummies?

------
Cozumel
Can anyone personally recommend it? It looks like a good investment!

~~~
MehdiHK
Bought it. Pretty basic stuffs:

\- Didn't learn anything new from Linux chapter.

\- Data Structures and Algorithms chapter is too basic. There is not even any
implementation provided. I thought it didn't offer anything more than you
could find on Wikipedia if you add some illustration done with Paper by 53
app. I'd recommend "Grokking Algorithms" by Aditya Bhargava for this topic if
you want illustrated explanations with brilliant examples.

\- Didn't learn anything new from Databases chapter.

\- Didn't learn anything new from Programming Languages chapter. Inclusion of
useless things like TIOBE Index made me furious, honestly.

\- Didn't learn anything new from Software Design chapter.

I won't recommend this book to anyone working in software engineering for more
or less 5 years with or without CS degree. This book merely serves as an index
of what you'll encounter in the field, nothing more than that. Not even any
good elaborations on those topics. Pretty meh.

~~~
asciimo
Thanks for mentioning Grokking Algorithms. Looks great, and might be the first
non-digital tech book I will have bought in years.

~~~
MehdiHK
It deserves to be in the bookshelves. :)

------
jcbeard
Anybody else vaguely reminded of The Fountainhead's cover:
[http://www.steinerag.com/flw/Book%20Images/Fountainhead1994....](http://www.steinerag.com/flw/Book%20Images/Fountainhead1994.jpg)

For some reason the combination of "imposter" and the colors evoked memories
of an old paperback.

~~~
lamacase
The cover actually appears to be one of the jpl "visions of the future"
posters.

[http://www.jpl.nasa.gov/visions-of-the-
future/images/superea...](http://www.jpl.nasa.gov/visions-of-the-
future/images/superearth-small.jpg)

I hope the author has permission to use it?

~~~
squeaky-clean
NASA are extremely liberal with how you're allowed to use these images. There
are other people selling prints of them, for example.

"Unless otherwise noted, images and video on JPL public web sites (public
sites ending with a jpl.nasa.gov address) may be used for any purpose without
prior permission, subject to the special cases noted below."

The "special cases" mostly deal with using the NASA or JPL logos, or using
photos with real humans in them commercially.

[http://www.jpl.nasa.gov/imagepolicy/](http://www.jpl.nasa.gov/imagepolicy/)

------
_pmf_
From Cargo Culter to Yak Shaver in 2 weeks or your money back!

