I Can Code

Anyone Can Code: The Art and Science of Logical Creativity introduces computer programming as a way of problem-solving through logical thinking. It uses the notion of modularization as a central lens through which we can make sense of many software concepts. This book takes the reader through fundamental concepts in programming by illustrating them in three different and distinct languages: C/C++, Python, and Javascript. Key features: Focuses on problem-solving and algorithmic thinking instead of programming functions, syntax, and libraries. Includes engaging examples, including video games and visual effects. Provides exercises and reflective questions. This book gives beginner and intermediate learners a strong understanding of what they are doing so that they can do it better and with any other tool or language that they may end up using later. Sample code is available on the author’s website.

All aboard The Coding Train! This beginner-friendly creative coding tutorial is designed to grow your skills in a fun, hands-on way as you build simulations of real-world phenomena with “The Coding Train” YouTube star Daniel Shiffman. How can we use code to capture the unpredictable properties of nature? How can understanding the mathematical principles behind our physical world help us create interesting digital environments? Written by “The Coding Train” YouTube star Daniel Schiffman, The Nature of Code is a beginner-friendly creative coding tutorial that explores a range of programming strategies for developing computer simulations of natural systems—from elementary concepts in math and physics to sophisticated machine-learning algorithms. Using the same enthusiastic style on display in Schiffman’s popular YT channel, this book makes learning to program fun, empowering you to generate fascinating graphical output while refining your problem-solving and algorithmic-thinking skills. You’ll progress from building a basic physics engine that simulates the effects of forces like gravity and wind resistance, to creating evolving systems of intelligent autonomous agents that can learn from their mistakes and adapt to their environment. The Nature of Code introduces important topics such as: Randomness Forces and vectors Trigonometry Cellular automata and fractals Genetic algorithms Neural networks Learn from an expert how to transform your beginner-level skills into writing well-organized, thoughtful programs that set the stage for further experiments in generative design. NOTE: All examples are written with p5.js, a JavaScript library for creative coding, and are available on the book's website.

A complete, self-contained coding course for absolute beginners. No prior knowledge of coding required - if you can switch on a computer, you can use this book!

Widely considered one of the best practical guides to programming, Steve McConnell’s original CODE COMPLETE has been helping developers write better software for more than a decade. Now this classic book has been fully updated and revised with leading-edge practices—and hundreds of new code samples—illustrating the art and science of software construction. Capturing the body of knowledge available from research, academia, and everyday commercial practice, McConnell synthesizes the most effective techniques and must-know principles into clear, pragmatic guidance. No matter what your experience level, development environment, or project size, this book will inform and stimulate your thinking—and help you build the highest quality code. Discover the timeless techniques and strategies that help you: Design for minimum complexity and maximum creativity Reap the benefits of collaborative development Apply defensive programming techniques to reduce and flush out errors Exploit opportunities to refactor—or evolve—code, and do it safely Use construction practices that are right-weight for your project Debug problems quickly and effectively Resolve critical construction issues early and correctly Build quality into the beginning, middle, and end of your project

Imagine Designing and Building Your Own Video Games. Codi loved playing video games but with three brothers and one television, she often just watched her brothers play for hours. Then one day, she had a brilliant idea: why not make my own video game? Follow Codi’s journey and see how she made her dream come true. Have fun as you learn the steps to achieving any goal: organize, do research, and put a plan into action. And while you are at it, meet Codi’s heroes, some of the brilliant African American women in STEM who have inspired her. Codi’s story will motivate you to learn to code, dream big, and believe in yourself. Also included in this book are challenging games such as cryptograms, puzzles, and Sudoku along with relaxing coloring book pages of some Codi’s heroes. Read Codi Can Code and You Can Too and take that bold step, today!

Chapter 5. Knowing What to Comment; What NOT to Comment; Don't Comment Just for the Sake of Commenting; Don't Comment Bad Names--Fix the Names Instead; Recording Your Thoughts; Include "Director Commentary"; Comment the Flaws in Your Code; Comment on Your Constants; Put Yourself in the Reader's Shoes; Anticipating Likely Questions; Advertising Likely Pitfalls; "Big Picture" Comments; Summary Comments; Final Thoughts--Getting Over Writer's Block; Summary; Chapter 6. Making Comments Precise and Compact; Keep Comments Compact; Avoid Ambiguous Pronouns; Polish Sloppy Sentences.

Refactoring is gaining momentum amongst the object oriented programming community. It can transform the internal dynamics of applications and has the capacity to transform bad code into good code. This book offers an introduction to refactoring.

Even bad code can function. But if code isn’t clean, it can bring a development organization to its knees. Every year, countless hours and significant resources are lost because of poorly written code. But it doesn’t have to be that way. Noted software expert Robert C. Martin presents a revolutionary paradigm with Clean Code: A Handbook of Agile Software Craftsmanship. Martin has teamed up with his colleagues from Object Mentor to distill their best agile practice of cleaning code “on the fly” into a book that will instill within you the values of a software craftsman and make you a better programmer–but only if you work at it. What kind of work will you be doing? You’ll be reading code–lots of code. And you will be challenged to think about what’s right about that code, and what’s wrong with it. More importantly, you will be challenged to reassess your professional values and your commitment to your craft. Clean Code is divided into three parts. The first describes the principles, patterns, and practices of writing clean code. The second part consists of several case studies of increasing complexity. Each case study is an exercise in cleaning up code–of transforming a code base that has some problems into one that is sound and efficient. The third part is the payoff: a single chapter containing a list of heuristics and “smells” gathered while creating the case studies. The result is a knowledge base that describes the way we think when we write, read, and clean code. Readers will come away from this book understanding How to tell the difference between good and bad code How to write good code and how to transform bad code into good code How to create good names, good functions, good objects, and good classes How to format code for maximum readability How to implement complete error handling without obscuring code logic How to unit test and practice test-driven development This book is a must for any developer, software engineer, project manager, team lead, or systems analyst with an interest in producing better code.

Big, brainy science for the littlest listeners. Accurate enough to satisfy an expert, yet simple enough for baby, this clever board book showcases the use of logic, sequence, and patterns to solve problems. Can Baby think like a coder to fix her train? Beautiful, visually stimulating illustrations complement age-appropriate language to encourage baby's sense of wonder. Parents and caregivers may learn a thing or two, as well! Author's Note: The goal of the Baby Loves Science books is to introduce STEM topics in a developmentally appropriate way. As a precursor to learning programming languages and syntax, Baby Loves Coding presents the concepts of sequencing, problem solving, cause and effect, and thinking step-by-step. Practicing these skills early creates a solid foundation for reading, writing, math and eventually, programming.

Have you ever felt frustrated working with someone else’s code? Difficult-to-maintain source code is a big problem in software development today, leading to costly delays and defects. Be part of the solution. With this practical book, you’ll learn 10 easy-to-follow guidelines for delivering Java software that’s easy to maintain and adapt. These guidelines have been derived from analyzing hundreds of real-world systems. Written by consultants from the Software Improvement Group (SIG), this book provides clear and concise explanations, with advice for turning the guidelines into practice. Examples for this edition are written in Java, while our companion C# book provides workable examples in that language. Write short units of code: limit the length of methods and constructors Write simple units of code: limit the number of branch points per method Write code once, rather than risk copying buggy code Keep unit interfaces small by extracting parameters into objects Separate concerns to avoid building large classes Couple architecture components loosely Balance the number and size of top-level components in your code Keep your codebase as small as possible Automate tests for your codebase Write clean code, avoiding "code smells" that indicate deeper problems

Learn how to code while you write programs that effortlessly perform useful feats of automation! The second edition of this international fan favorite includes a brand-new chapter on input validation, Gmail and Google Sheets automations, tips for updating CSV files, and more. If you've ever spent hours renaming files or updating spreadsheet cells, you know how tedious tasks like these can be. But what if you could have your computer do them for you? Automate the Boring Stuff with Python, 2nd Edition teaches even the technically uninclined how to write programs that do in minutes what would take hours to do by hand—no prior coding experience required! This new, fully revised edition of Al Sweigart’s bestselling Pythonic classic, Automate the Boring Stuff with Python, covers all the basics of Python 3 while exploring its rich library of modules for performing specific tasks, like scraping data off the Web, filling out forms, renaming files, organizing folders, sending email responses, and merging, splitting, or encrypting PDFs. There’s also a brand-new chapter on input validation, tutorials on automating Gmail and Google Sheets, tips on automatically updating CSV files, and other recent feats of automations that improve your efficiency. Detailed, step-by-step instructions walk you through each program, allowing you to create useful tools as you build out your programming skills, and updated practice projects at the end of each chapter challenge you to improve those programs and use your newfound skills to automate similar tasks. Boring tasks no longer have to take to get through—and neither does learning Python!

Usually we think of coding as something only trained experts and scientists can handle, but not any more thanks to programs like Python. First developed in 1991, Python uses lines of code, letters, and symbols, to create computer programs. Python is easier to read and takes fewer lines of code to accomplish tasks than some programming languages. Python’s creator, Guido van Rossum, wanted to create open-source software that used easy-to-understand coding text. His software allows even novice programmers to see results in a short amount of time. Vivid photographs, sidebars, and a graphic organizer help make this STEM-centric volume a dynamic learning experience.

Coding was once an inaccessible activity for elementary students, but not any more. Scratch is an exciting and easy-to-learn coding program for people of all ages. Instead of lines of text, users code by dragging and dropping colorful, stackable blocks to create animations. With this colorful, intuitive, and simple application, even new Scratch users will begin to understand the logic behind coding in just minutes! Coding examples and photographs of age-appropriate students help readers feel at ease with STEM concepts. Sidebars and a graphic organizer help readers get the most out of this informative volume.

"Ali Arya guides you in a fantastic journey full of creativity in a coherent way that allows the traveler to learn and build up over the knowledge acquired in previous chapters until the reader accomplishes skills to develop solutions using programming." — Andrés A. Navarro Newball, Professor, Pontificia Universidad Javeriana, Cali, Colombia "An excellent book that teaches programming and software development the way it should be done: independent from a specific implementation language and focusing on the main principles that are fundamental and substantive to any kind of software production." — Marc Conrad, Principal Lecturer, University of Bedfordshire, Luton, UK Anyone Can Code: The Art and Science of Logical Creativity introduces computer programming as a way of problem-solving through logical thinking. It uses the notion of modularization as a central lens through which we can make sense of many software concepts. This book takes the reader through fundamental concepts in programming by illustrating them in three different and distinct languages: C/C++, Python, and Javascript. Key features: Focuses on problem-solving and algorithmic thinking instead of programming functions, syntax, and libraries Includes engaging examples, including video games and visual effects Provides exercises and reflective questions This book gives beginner and intermediate learners a strong understanding of what they are doing so that they can do it better and with any other tool or language that they may end up using later. Author Ali Arya is an Associate Professor in the School of Information Technology at Carleton University, Ottawa, Canada. He received his PhD in Computer Engineering from the University of British Columbia, Vancouver, Canada, in 2003. He has over 25 years of experience in professional and academic positions related to software development and information technology. He is passionate about computer programming that brings together logical and creative abilities.

This book is for the career developer who wants to take his or her skill set and/or project to the next level. If you are a professional software developer with 3–4 years of experience looking to bring a higher level of discipline to your project, or to learn the skills that will help you transition from software engineer to technical lead, then this book is for you. The topics covered in this book will help you focus on delivering software at a higher quality and lower cost. The book is about practical techniques and practices that will help you and your team realize those goals. This book is for the developer understands that the business of software is, first and foremost, business. Writing code is fun, but writing high-quality code on time and at the lowest possible cost is what makes a software project successful. A team lead or architect who wants to succeed must keep that in mind. Given that target audience, this book assumes a certain level of skill at reading code in one or more languages, and basic familiarity with building and testing software projects. It also assumes that you have at least a basic understanding of the software development lifecycle, and how requirements from customers become testable software projects. Who This Book Is Not For: This is not a book for the entry-level developer fresh out of college, or for those just getting started as professional coders. It isn’t a book about writing code; it’s a book about how we write code together while keeping quality up and costs down. It is not for those who want to learn to write more efficient or literate code. There are plenty of other books available on those subjects, as mentioned previously. This is also not a book about project management or development methodology. All of the strategies and techniques presented here are just as applicable to waterfall projects as they are to those employing Agile methodologies. While certain strategies such as Test-Driven Development and Continuous Integration have risen to popularity hand in hand with Agile development methodologies, there is no coupling between them. There are plenty of projects run using SCRUM that do not use TDD, and there are just as many waterfall projects that do. Philosophy versus Practicality: There are a lot of religious arguments in software development. Exceptions versus result codes, strongly typed versus dynamic languages, and where to put your curly braces are just a few examples. This book tried to steer clear of those arguments here. Most of the chapters in this book deal with practical steps that you as a developer can take to improve your skills and improve the state of your project. The author makes no claims that these practices represent the way to write software. They represent strategies that have worked well for the author and other developers that he have worked closely with. Philosophy certainly has its place in software development. Much of the current thinking in project management has been influenced by the Agile philosophy, for example. The next wave may be influenced by the Lean methodologies developed by Toyota for building automobiles. Because it represents a philosophy, the Lean process model can be applied to building software just as easily as to building cars. On the other hand, because they exist at the philosophical level, such methodologies can be difficult to conceptualize. The book tries to favor the practical over the philosophical, the concrete over the theoretical. This should be the kind of book that you can pick up, read one chapter of, and go away with some practical changes you can make to your software project that will make it better. That said, the first part of this book is entitled “Philosophy” because the strategies described in it represent ways of approaching a problem rather than a specific solution. There are just as many practical ways to do Test-Driven Development as there are ways to manage a software project. You will have to pick the way that fits your chosen programming language, environment, and team structure. The book has tried to describe some tangible ways of realizing TDD, but it remains an abstract ideal rather than a one-size-fits-all technical solution. The same applies to Continuous Integration. There are numerous ways of thinking about and achieving a Continuous Integration solution, and this book presents only a few. Continuous Integration represents a way of thinking about your development process rather than a concrete or specific technique. The second and third parts represent more concrete process and construction techniques that can improve your code and your project. They focus on the pragmatic rather than the philosophical. Every Little Bit Helps: You do not have to sit down and read this book from cover to cover. While there are interrelationships between the chapters, each chapter can also stand on its own. If you know that you have a particular problem such as error handling with your current project, read that chapter and try to implement some of the suggestions in it. Don’t feel that you have to overhaul your entire software project at once. The various techniques described in this book can all incrementally improve a project one at a time. If you are starting a brand new project and have an opportunity to define its structure, then by all means read the whole book and see how it influences the way you design your project. If you have to work within an existing project structure, you might have more success applying a few improvements at a time. In terms of personal career growth, the same applies. Every new technique you learn makes you a better developer, so take them one at a time as your schedule and projects allow. Examples: Most of the examples in this book are written in C#. However, the techniques described in this book apply just as well to any other modern programming language with a little translation. Even if you are unfamiliar with the inner workings or details of C# as a language, the examples are very small and simple to understand. Again, this is not a book about how to write code, and the examples in it are all intended to illustrate a specific point, not to become a part of your software project in any literal sense. This book is organized into three sections, Philosophy, Process and Code Construction. The following is a short summary of what you will find in each section and chapter. Part I (Philosophy) contains chapters that focus on abstract ideas about how to approach a software project. Each chapter contains practical examples of how to realize those ideas. Chapter 1 (Buy, not Build) describes how to go about deciding which parts of your software project you need to write yourself and which parts you may be able to purchase or otherwise leverage from someplace else. In order to keep costs down and focus on your real competitive advantage, it is necessary to write only those parts of your application that you really need to. Chapter 2 (Test-Driven Development) examines the Test-Driven Development (or Test-Driven Design) philosophy and some practical ways of applying it to your development lifecycle to produce higher-quality code in less time. Chapter 3 (Continuous Integration) explores the Continuous Integration philosophy and how you can apply it to your project. CI involves automating your build and unit testing processes to give developers a shorter feedback cycle about changes that they make to the project. A shorter feedback cycle makes it easier for developers to work together as a team and at a higher level of productivity. The chapters in Part II (Process) explore processes and tools that you can use as a team to improve the quality of your source code and make it easier to understand and to maintain. Chapter 4 (Done Is Done) contains suggestions for defining what it means for a developer to “finish” a development task. Creating a “done is done” policy for your team can make it easier for developers to work together, and easier for developers and testers to work together. If everyone on your team follows the same set of steps to complete each task, then development will be more predictable and of a higher quality. Chapter 5 (Testing) presents some concrete suggestions for how to create tests, how to run them, and how to organize them to make them easier to run, easier to measure, and more useful to developers and to testers. Included are sections on what code coverage means and how to measure it effectively, how to organize your tests by type, and how to automate your testing processes to get the most benefit from them. Chapter 6 (Source Control) explains techniques for using your source control system more effectively so that it is easier for developers to work together on the same project, and easier to correlate changes in source control with physical software binaries and with defect or issue reports in your tracking system. Chapter 7 (Static Analysis) examines what static analysis is, what information it can provide, and how it can improve the quality and maintainability of your projects. Part III (Code Construction) includes chapters on specific coding techniques that can improve the quality and maintainability of your software projects. Chapter 8 (Contract, Contract, Contract!) tackles programming by contract and how that can make your code easier for developers to understand and to use. Programming by contract can also make your application easier (and therefore less expensive) to maintain and support. Chapter 9 (Limiting Dependencies) focuses on techniques for limiting how dependent each part of your application is upon the others. Limiting dependencies can lead to software that is easier to make changes to and cheaper to maintain as well as easier to deploy and test. Chapter 10 (The Model-View-Presenter Model) offers a brief description of the MVP model and explains how following the MVP model will make your application easier to test. Chapter 11 (Tracing) describes ways to make the most of tracing in your application. Defining and following a solid tracing policy makes your application easier to debug and easier for your support personnel and/or your customers to support. Chapter 12 (Error Handing) presents some techniques for handling errors in your code that if followed consistently make your application easier to debug and to support. Part IV (Putting It All Together) is simply a chapter that describes a day in the life of a developer who is following the guiding principles and using the techniques described in the rest of the book. Chapter 13 (Calculator Project: A Case Study) shows many of this book’s principles and techniques in actual use.

How do the experts solve difficult problems in software development? In this unique and insightful book, leading computer scientists offer case studies that reveal how they found unusual, carefully designed solutions to high-profile projects. You will be able to look over the shoulder of major coding and design experts to see problems through their eyes. This is not simply another design patterns book, or another software engineering treatise on the right and wrong way to do things. The authors think aloud as they work through their project's architecture, the tradeoffs made in its construction, and when it was important to break rules. This book contains 33 chapters contributed by Brian Kernighan, KarlFogel, Jon Bentley, Tim Bray, Elliotte Rusty Harold, Michael Feathers,Alberto Savoia, Charles Petzold, Douglas Crockford, Henry S. Warren,Jr., Ashish Gulhati, Lincoln Stein, Jim Kent, Jack Dongarra and PiotrLuszczek, Adam Kolawa, Greg Kroah-Hartman, Diomidis Spinellis, AndrewKuchling, Travis E. Oliphant, Ronald Mak, Rogerio Atem de Carvalho andRafael Monnerat, Bryan Cantrill, Jeff Dean and Sanjay Ghemawat, SimonPeyton Jones, Kent Dybvig, William Otte and Douglas C. Schmidt, AndrewPatzer, Andreas Zeller, Yukihiro Matsumoto, Arun Mehta, TV Raman,Laura Wingerd and Christopher Seiwald, and Brian Hayes. Beautiful Code is an opportunity for master coders to tell their story. All author royalties will be donated to Amnesty International.

Deep learning is often viewed as the exclusive domain of math PhDs and big tech companies. But as this hands-on guide demonstrates, programmers comfortable with Python can achieve impressive results in deep learning with little math background, small amounts of data, and minimal code. How? With fastai, the first library to provide a consistent interface to the most frequently used deep learning applications. Authors Jeremy Howard and Sylvain Gugger, the creators of fastai, show you how to train a model on a wide range of tasks using fastai and PyTorch. You’ll also dive progressively further into deep learning theory to gain a complete understanding of the algorithms behind the scenes. Train models in computer vision, natural language processing, tabular data, and collaborative filtering Learn the latest deep learning techniques that matter most in practice Improve accuracy, speed, and reliability by understanding how deep learning models work Discover how to turn your models into web applications Implement deep learning algorithms from scratch Consider the ethical implications of your work Gain insight from the foreword by PyTorch cofounder, Soumith Chintala

Literate programming is a programming methodology that combines a programming language with a documentation language, making programs more easily maintained than programs written only in a high-level language. A literate programmer is an essayist who writes programs for humans to understand. When programs are written in the recommended style they can be transformed into documents by a document compiler and into efficient code by an algebraic compiler. This anthology of essays includes Knuth's early papers on related topics such as structured programming as well as the Computer Journal article that launched literate programming. Many examples are given, including excerpts from the programs for TeX and METAFONT. The final essay is an example of CWEB, a system for literate programming in C and related languages. Index included.