Street Coder

Book description

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.

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!

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 Kapanoğlu 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.

Quotes
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, KPMG Austria

This is the book that I wish I’d had when I started in the world of application development.
- Janek López, Fosh Tech

This is one book I will be re-reading.
- Brent Honadel

I started my career as a street coder, and wish I had read this book at that time so I could have avoided many detours and saved a few years of my career.
- Xu Yang, Ansteel Group

There are few books which a developer or an architect can keep in their bookshelf forever. This is one such book.
- Tiklu Ganguly

A fantastic read, particularly for developers just beginning their first proper job in the industry, but also a worthwhile investment for more experienced developers.
- Jonny Nisbet

A must-read for every developer level!
- Vincent Delcoigne, Wavenet

In the real world you have some tough decisions to make and the formal theory that you learned in your CS study or courses won't be enough—thus I really appreciate the message that this book delivers: know what matters in the streets, be questioning and results-driven, and embrace complexity and ambiguity.
- Asil Çetin-Aufricht, KPMG Austria

I find the "streets" metaphor of the book especially on point.
- Asil Çetin-Aufricht, KPMG Austria

Table of contents

  1. inside front cover
  2. Street Coder
  3. Copyright
  4. dedication
  5. contents
  6. front matter
    1. preface
    2. acknowledgments
    3. about this book
      1. Who should read this book
    4. How this book is organized: A road map
      1. About the code
      2. liveBook discussion forum
    5. about the author
    6. about the cover illustration
  7. 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
      1. 1.3.1 Questioning
      2. 1.3.2 Results-driven
      3. 1.3.3 High-throughput
      4. 1.3.4 Embracing complexity and ambiguity
    4. 1.4 The problems of modern software development
      1. 1.4.1 Too many technologies
      2. 1.4.2 Paragliding on paradigms
      3. 1.4.3 The black boxes of technology
      4. 1.4.4 Underestimating overhead
      5. 1.4.5 Not my job
      6. 1.4.6 Menial is genial
    5. 1.5 What this book isn’t
    6. 1.6 Themes
    7. Summary
  8. 2 Practical theory
    1. 2.1 A crash course on algorithms
      1. 2.1.1 Big-O better be good
    2. 2.2 Inside data structures
      1. 2.2.1 String
      2. 2.2.2 Array
      3. 2.2.3 List
      4. 2.2.4 Linked list
      5. 2.2.5 Queue
      6. 2.2.6 Dictionary
      7. 2.2.7 HashSet
      8. 2.2.8 Stack
      9. 2.2.9 Call stack
    3. 2.3 What’s the hype on types?
      1. 2.3.1 Being strong on the type
      2. 2.3.2 Proof of validity
      3. 2.3.3 Don’t framework hard, framework smart
      4. 2.3.4 Types over typos
      5. 2.3.5 To be nullable or non-nullable
      6. 2.3.6 Better performance for free
      7. 2.3.7 Reference types vs. value types
    4. Summary
  9. 3 Useful anti-patterns
    1. 3.1 If it ain’t broke, break it
      1. 3.1.1 Facing code rigidity
      2. 3.1.2 Move fast, break things
      3. 3.1.3 Respecting boundaries
      4. 3.1.4 Isolating common functionality
      5. 3.1.5 Example web page
      6. 3.1.6 Leave no debt behind
    2. 3.2 Write it from scratch
      1. 3.2.1 Erase and rewrite
    3. 3.3 Fix it, even if it ain’t broke
      1. 3.3.1 Race toward the future
      2. 3.3.2 Cleanliness is next to codeliness
    4. 3.4 Do repeat yourself
      1. 3.4.1 Reuse or copy?
    5. 3.5 Invent it here
    6. 3.6 Don’t use inheritance
    7. 3.7 Don’t use classes
      1. 3.7.1 Enum is yum!
      2. 3.7.2 Structs rock!
    8. 3.8 Write bad code
      1. 3.8.1 Don’t use If/Else
      2. 3.8.2 Use goto
    9. 3.9 Don’t write code comments
      1. 3.9.1 Choose great names
      2. 3.9.2 Leverage functions
    10. Summary
  10. 4 Tasty testing
    1. 4.1 Types of tests
      1. 4.1.1 Manual testing
      2. 4.1.2 Automated tests
      3. 4.1.3 Living dangerously: Testing in production
      4. 4.1.4 Choosing the right testing methodology
    2. 4.2 How to stop worrying and love the tests
    3. 4.3 Don’t use TDD or other acronyms
    4. 4.4 Write tests for your own good
    5. 4.5 Deciding what to test
      1. 4.5.1 Respect boundaries
      2. 4.5.2 Code coverage
    6. 4.6 Don’t write tests
      1. 4.6.1 Don’t write code
      2. 4.6.2 Don’t write all the tests
    7. 4.7 Let the compiler test your code
      1. 4.7.1 Eliminate null checks
      2. 4.7.2 Eliminate range checks
      3. 4.7.3 Eliminate valid value checks
    8. 4.8 Naming tests
    9. Summary
  11. 5 Rewarding refactoring
    1. 5.1 Why do we refactor?
    2. 5.2 Architectural changes
      1. 5.2.1 Identify the components
      2. 5.2.2 Estimate the work and the risk
      3. 5.2.3 The prestige
      4. 5.2.4 Refactor to make refactoring easier
      5. 5.2.5 The final stretch
    3. 5.3 Reliable refactoring
    4. 5.4 When not to refactor
    5. Summary
  12. 6 Security by scrutiny
    1. 6.1 Beyond hackers
    2. 6.2 Threat modeling
      1. 6.2.1 Pocket-sized threat models
    3. 6.3 Write secure web apps
      1. 6.3.1 Design with security in mind
      2. 6.3.2 Usefulness of security by obscurity
      3. 6.3.3 Don’t implement your own security
      4. 6.3.4 SQL injection attacks
      5. 6.3.5 Cross-site scripting
      6. 6.3.6 Cross-site request forgery
    4. 6.4 Draw the first flood
      1. 6.4.1 Don’t use captcha
      2. 6.4.2 Captcha alternatives
      3. 6.4.3 Don’t implement a cache
    5. 6.5 Storing secrets
      1. 6.5.1 Keeping secrets in source code
    6. Summary
  13. 7 Opinionated optimization
    1. 7.1 Solve the right problem
      1. 7.1.1 Simple benchmarking
      2. 7.1.2 Performance vs. responsiveness
    2. 7.2 Anatomy of sluggishness
    3. 7.3 Start from the top
      1. 7.3.1 Nested loops
      2. 7.3.2 String-oriented programming
      3. 7.3.3 Evaluating 2b || !2b
    4. 7.4 Breaking the bottle at the neck
      1. 7.4.1 Don’t pack data
      2. 7.4.2 Shop local
      3. 7.4.3 Keep dependent works separated
      4. 7.4.4 Be predictable
      5. 7.4.5 SIMD
    5. 7.5 1s and 0s of I/O
      1. 7.5.1 Make I/O faster
      2. 7.5.2 Make I/O non-blocking
      3. 7.5.3 The archaic ways
      4. 7.5.4 Modern async/await
      5. 7.5.5 Gotchas of async I/O
    6. 7.6 If all else fails, cache
    7. Summary
  14. 8 Palatable scalability
    1. 8.1 Don’t use locks
      1. 8.1.1 Double-checked locking
    2. 8.2 Embrace inconsistency
      1. 8.2.1 The dreaded NOLOCK
    3. 8.3 Don’t cache database connections
      1. 8.3.1 In the form of an ORM
    4. 8.4 Don’t use threads
      1. 8.4.1 The gotchas of async code
      2. 8.4.2 MULTITHREADING with async
    5. 8.5 Respect the monolith
    6. Summary
  15. 9 Living with bugs
    1. 9.1 Don’t fix bugs
    2. 9.2 The error terror
      1. 9.2.1 The bare truth of exceptions
      2. 9.2.2 Don’t catch exceptions
      3. 9.2.3 Exception resiliency
      4. 9.2.4 Resiliency without transactions
      5. 9.2.5 Exceptions vs. errors
    3. 9.3 Don’t debug
      1. 9.3.1 printf() debugging
      2. 9.3.2 Dump diving
      3. 9.3.3 Advanced rubber-duck debugging
    4. Summary
  16. index
  17. inside back cover

Product information

  • Title: Street Coder
  • Author(s): Sedat Kapanoglu
  • Release date: January 2022
  • Publisher(s): Manning Publications
  • ISBN: 9781617298370