O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Computational Thinking - A beginner's guide to problem-solving and programming

Book Description

Computational thinking (CT) is a timeless, transferable skill that enables you to think more clearly and logically, as well as a way to solve specific problems. With this book you'll learn to apply computational thinking in the context of software development to give you a head start on the road to becoming an experienced and effective programmer. Beginning with the core ideas of computational thinking, with this book you'll build up an understanding of the practical problem-solving approach and explore how computational thinking aids good practice in programming, complete with a full guided example. ----- 'A scholarly book albeit written from a pragmatic perspective distilling the knowledge and expertise of an experienced software developer into a form that is accessible for beginners. It's engaging exercises and comprehensive references make it an invaluable learning resource. I would recommend it to anyone who wishes to gain an understanding of computational thinking and best practice in modern software development.' Professor Cornelia Boldyreff, University of Greenwich ----- 'This book will prove an excellent companion to more general texts on Computing, especially for teachers who are new to the subject. And with exercises at the end of each chapter, there is much to challenge students also. Highly recommended.' Terry Freedman , independent education technology writer and consultant, and publisher of the ICT and Computing in Education website at www.ictineducation.org ----- 'A ‘must-read’ for students embarking on their first major projects, and any teacher stepping up to the challenge of teaching Computing at school. This is not just a book about programming, more a template for teaching. Karl Beecher speaks in plain English. Incisive insight and practical advice, standing independent of the Python exemplars used, predicated as it is on a holistic understanding of the subject terrain.' Roger Davies, Director of IT, Queen Elizabeth School, and Editor, Computing At School, Tenderfoot Training Project

Table of Contents

  1. Front Cover
  2. Half Title
  3. BCS, THE CHARTERED INSTITUTE FOR IT
  4. Title Page
  5. Copyright Page
  6. Contents
  7. List of figures and tables
  8. Author
  9. Acknowledgements
  10. Glossary
  11. Introduction: Why Study Computational Thinking?
  12. Part I Computational Thinking
  13. 1. What is Computational Thinking?
  14. Objectives
  15. What is computational thinking?
  16. How is computational thinking used?
  17. Disclaimers
  18. Summary
  19. Exercises
  20. 2. Logical and Algorithmic Thinking
  21. Objectives
  22. Approach
  23. Logical thinking
  24. Algorithmic thinking
  25. ‘Gotchas’
  26. Summary
  27. Exercises
  28. 3. Problem-Solving and Decomposition
  29. Objectives
  30. Where to start
  31. Defining the problem
  32. Devising a solution: Something to keep in mind
  33. Decomposition
  34. Other effective strategies
  35. Patterns and generalisation
  36. Summary
  37. Exercises
  38. 4. Abstraction and Modelling
  39. Objectives
  40. Abstraction
  41. Modelling
  42. Summary
  43. Exercises
  44. 5. Anticipating and Dealing with Errors
  45. Objectives
  46. Coming to terms with bugs
  47. Designing out the bugs
  48. Mitigating errors
  49. Testing
  50. Debugging
  51. You can’t have everything: Deciding which errors to fix
  52. Summary
  53. Exercises
  54. 6. Evaluating A Solution
  55. Objectives
  56. Solution evaluation
  57. Is it correct?
  58. Is it efficient?
  59. Is it elegant?
  60. Is it usable?
  61. Trade-offs
  62. Summary
  63. Exercises
  64. Part II Computational Thinking in Software Development
  65. 7. Tutorial for Python Beginners
  66. Objectives
  67. Introducing Python
  68. First steps
  69. Basic types
  70. Basic operations
  71. Functions
  72. Comments
  73. Summary
  74. Exercises
  75. 8. Effective Building Blocks
  76. Objectives
  77. Logic
  78. Basic algorithmic constructs
  79. Program state
  80. More advanced constructs
  81. Summary
  82. Exercises
  83. 9. Organising Your Code
  84. Objectives
  85. Recap
  86. Introducing tkinter
  87. Separating concerns
  88. Defining information scope
  89. Using modules
  90. Packages
  91. Summary
  92. Exercises
  93. 10. Using Abstractions and Patterns
  94. Objectives
  95. Finding patterns in programs
  96. Abstractions in programming
  97. Built-in types
  98. Creating your own types
  99. Ready-made patterns
  100. Summary
  101. Exercises
  102. 11. Effective Modelling
  103. Objectives
  104. Recap
  105. Entities
  106. Relationships
  107. Processes
  108. Usage
  109. General advice
  110. Summary
  111. Exercises
  112. 12. Testing and Evaluating Programs
  113. Objectives
  114. Introduction to program testing and evaluation
  115. Anticipating bugs
  116. Verification and validation
  117. Testing the parts
  118. Testing the whole
  119. Debugging
  120. Summary
  121. Exercises
  122. 13. A Guided Example
  123. Problem definition
  124. Problem decomposition
  125. Finding patterns
  126. Form generalisations and abstractions
  127. Models
  128. Annotated source code
  129. Testing
  130. Opportunities for improvement
  131. Appendix A: Reference Lists and Tables
  132. Order of operator precedence
  133. Usability heuristics
  134. Mutable and immutable types in Python
  135. Appendix B: Answers to Exercises
  136. Notes
  137. References
  138. Index
  139. Back Cover