Street Coder: The rules to break and how to break them

by Sedat Kapanoglu

Overview

Computer science theory quickly collides with the harsh reality of professional software development. This wickedly smart and devilishly funny beginner's guide shows you how to get the job done by prioritizing tasks, making quick decisions, and knowing which rules to break.

—————

I've just finished the digital copy of this content-packed 274 pages of insightful technical guide and it definitely goes onto my list of useful sources for software developers, CS students, and even technical leads.

Asil Çetin-Aufricht, Team Lead, Software Development, KPMG Austria

In Street Coder you will learn:

Data types, algorithms, and data structures for speedy software development
Putting "bad" practices to good use
Learn to love testing
Embrace code breaks and become friends with failure
Beginner-friendly insight on code optimization, asynchronous programming, parallelization, and refactoring

Street Coder: Rules to break and how to break them is a programmer's survival guide, full of tips, tricks, and hacks that will make you a more efficient programmer. It takes the best practices you learn in a computer science class and deconstructs them to show when they’re beneficial—and when they aren't!

This book's rebel mindset challenges status quo thinking and exposes the important skills you need on the job. You'll learn the crucial importance of algorithms and data structures, turn programming chores into programming pleasures, and shatter dogmatic principles keeping you from your full potential. Welcome to the streets!

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

About the technology
Fresh-faced CS grads, bootcampers, and other junior developers lack a vital quality: the “street smarts” of experience. To succeed in software, you need the skills and discipline to put theory into action. You also need to know when to go rogue and break the unbreakable rules. Th is book is your survival guide.

About the book
Street Coder teaches you how to handle the realities of day-to-day coding as a software developer. Self-taught guru Sedat Kapanoglu shares down-and-dirty advice that’s rooted in his personal hands-on experience, not abstract theory or ivory-tower ideology. You’ll learn how to adapt what you’ve learned from books and classes to the challenges you’ll face on the job. As you go, you’ll get tips on everything from technical implementations to handling a paranoid manager.

What's inside

Beginner-friendly insights on code optimization, parallelization, and refactoring
Put “bad” practices to good use
Learn to love testing
Embrace code breaks and become friends with failure

About the reader
For new programmers. Examples in C#.

About the author
Sedat Kapanoglu is a self-taught programmer with more than 25 years of experience, including a stint at Microsoft.

Table of Contents
1 To the streets
2 Practical theory
3 Useful anti-patterns
4 Tasty testing
5 Rewarding refactoring
6 Security by scrutiny
7 Opinionated optimization
8 Palatable scalability
9 Living with bugs

Product Details

ISBN-13:	9781617298370
Publisher:	Manning
Publication date:	02/08/2022
Pages:	272
Product dimensions:	7.38(w) x 9.25(h) x 0.60(d)

About the Author

Sedat Kapanoglu is a self-taught programmer with more than 25 years of experience, including a stint at Microsoft.

Table of Contents

Preface xiii

Acknowledgments xv

About this book xvii

About the author xx

About the cover illustration xxi

1 To the streets 1

1.1 What matters in the streets 2

1.2 Who's a street coder? 3

1.3 Great street coders 4

Questioning 5

Results-driven 5

High-throughput 6

Embracing complexity and ambiguity 6

1.4 The problems of modern software development 7

Too many technologies 8

Paragliding on paradigms 9

The black boxes of technology 10

Underestimating overhead 11

Not my job 11

Menial is genial 11

1.5 What this book isn't 12

1.6 Themes 12

2 Practical theory 14

2.1 A crash course on algorithms 15

Big-O better be good 17

2.2 Inside data structures 19

Siring 20

Array 23

List 24

Linked list 25

Queue 26

Dictionary 26

HashSet 29

Stack 29

Call stack 30

2.3 What's the hype on types? 30

Being strong on the type 31

Proof of validity 32

Don't framework hard, framework smart 37

Types over typos 40

To be nullable or non-nullable 41

Better performance for free 47

Reference types vs. value types 49

3 Useful anti-patterns 53

3.1 If it ain't broke, break it 54

Facing code rigidity 54

Move fast, break things 55

Respecting boundaries 56

Isolating common functionality 57

Example web page 59

Leave no debt behind 60

3.2 Write it from scratch 61

Erase and rewrite 61

3.3 Fix it, even if it ain't broke 62

Race toward the future 62

Cleanliness is next to codeliness 64

3.4 Do repeat yourself 66

Reuse or copy? 70

3.5 Invent it here 71

3.6 Don't use inheritance 74

3.7 Don't use classes 76

Enum is yum! 76

Structs rock! 78

3.8 Write bad code 83

Don't use If/Else 83

Use goto 85

3.9 Don't write code comments 88

Choose great names 90

Leverage functions 90

4 Tasty testing 94

4.1 Types of tests 95

Manual testing 95

Automated tests 96

Living dangerously: Testing in production 96

Choosing the right testing methodology 97

4.2 How to stop worrying and love the tests 99

4.3 Don't use TDD or other acronyms 105

4.4 Write tests for your own good 106

4.5 Deciding what to test 107

Respect boundaries 107

Code coverage 110

4.6 Don't write tests 112

Don't write code 112

Don't write all the tests 112

4.7 Let the compiler test your code 113

Eliminate null checks 113

Eliminate range checks 116

Eliminate valid value checks 118

4.8 Naming tests 120

5 Rewarding refactoring 122

5.1 Why do we refactor? 123

5.2 Architectural changes 124

Identify the components 126

Estimate the work and the risk 127

The prestige 128

Refactor to make refactoring easier 129

The final stretch 135

5.3 Reliable refactoring 136

5.4 When not to refactor 138

6 Security by scrutiny 140

6.1 Beyond hackers 141

6.2 Threat modeling 142

Pocket-sized threat models 144

6.3 Write secure web apps 146

Design with security in mind 146

Usefulness of security by obscurity 147

Don't implement your own security 148

SQL injection attacks 149

Cross-site scripting 155

Cross-site request forgery 159

6.4 Draw the first flood 161

Don't use captcha 161

Captcha alternatives 162

Don't implement a cache 162

6.5 Storing secrets 163

Keeping secrets in source code 163

7 Opinionated optimization 171

7.1 Solve the right problem 172

Simple benchmarking 172

Performance vs. responsiveness 175

7.2 Anatomy of sluggishness 177

7.3 Start from the top 178

Nested loops 179

String-oriented programming 181

Evaluating 2b || !2b 182

l7.4 Breaking the bottle at the neck 183

Don't pack data 183

Shop local 185

Keep dependent works separated 185

Be predictable 187

SIMD 189

l7.5 Is and 0s of I/O 191

Make I/O faster 191

Make I/O non-blocking 193

The archaic ways 194

Modern async/await 195

Gotchas of async I/O 196

l7.6 If all else fails, cache 196

l8 Palatable scalability 198

l8.1 Don't use locks 199

Double-checked locking 206

l8.2 Embrace inconsistency 209

The dreaded NOLOCK 209

l8.3 Don't cache database connections 211

In the form of an ORM 214

l8.4 Don't use threads 215

The gotchas of async code 219

MULTITHREADING with async 219

l8.5 Respect the monolith 220

l9 Living with hugs 222

l9.1 Don't fix bugs 223

l9.2 The error terror 224

The bare truth of exceptions 225

Don't catch exceptions 227

Exception resiliency 229

Resiliency without transactions 233

Exceptions vs. errors 234

l9.3 Don't debug 236

Printf() debugging 236

Dump diving 237

Advanced rubber-duck debugging 240

Index 243