Learn Objective-C in 24 Days

Yep, that title says 24 DAYS, not hours. You can’t learn a programming language in 24 hours. Publishers say you can, but that’s just for marketing purposes.

To really learn a language — to the point where you don’t have to look back through a book every other line — takes time.

It takes time to do the exercises. It takes time to formulate questions, and answer them for yourself (although I’ll be glad to answer any to the best of my ability). It takes time to let the language sink in.

I’m starting a series that will attempt to teach the Objective-C language. As Stephen Kochan did in his book, I will attempt to teach plain C and Obj-C as one language. I don’t know how long it’ll take to complete — we’ll see.

I want to do a solid job of teaching the language though. This post will be updated as an index of all the lessons. I hope to have the first one out by the end of the week.

My goal is to teach the series at a comfortable pace for most people. I want it to be a fun and engaging experience, and an easy place for beginners to begin their coding journey. As always, comments and criticisms are appreciated.

Download a copy of Xcode, and get ready to learn!

Here are my goals for the course:

  1. As I mentioned before, I will attempt to teach C and Objective-C as one language. Obj-C is a strict superset of plain C, which means that any valid C is also valid Obj-C. The reason for this decision is that C is a procedural language, where you worry about how you do a task, whereas Obj-C is an object-orientated language, where you worry about what you use to do a task. It’s a radical shift in mindset. As a result, although Obj-C builds smoothly off of plain C, not all C styles and procedures work with Obj-C.
  2. I want to engage, not just present the facts. As a result, I will supply plenty of screenshots, and include exercises at the end of each lesson. I will also post the source code to each lesson on this blog.
  3. I want to create a solid understanding that frees you from having to go back to a reference every other line of code. That gets annoying, and you won’t get much respect in programming circles. 😛
  4. I want to make it an easy and fluid learning environment. People learn better when they are subject to less stress. In fact, I’m not going to stress you at all—you’ll be your own motivator. You want to build the next great iPhone app — so put in the effort! In this course, I hope to build up a small code library, and have each lesson build up off the previous.

Directory of Lessons:

  1. A Brief History of Objective-C
  2. Language Concepts
  3. Back to Basics: How Programming Languages Work
  4. Lesson 1: Hello, World!
  5. Lesson 2: Basic Variables
  6. Lesson 3: Object-Oriented Programming
  7. Lesson 4: if() statements and Booleans
  8. Extending “Hello, World!”
  9. Reserved Keywords
  10. Escape Sequences and Format Specifiers
  11. Integer Operations
  12. Floating-Point Operations
  13. ASCII, Booleans and Characters
  14. Conditional Operator
  15. What Goes Inside the if() Statement
  16. The switch Statement
  17. Lesson 5: Loops
  18. Incrementation
  19. Loop Aids
  20. Creating a New iPhone Project
  21. Objects (Part 1): Splitting Classes Into Multiple Files
  22. Objects (Part 2): Properties
  23. Objects (Part 3): Extending the Fraction Class
  24. Objects (Part 4): Inheritance — iVars & Methods
  25. Objects (Part 5): Inheritance — Extending & Overriding
  26. Objects (Part 6): Inheritance — Some Loose Ends
  27. Objects (Part 7): Introspection
  28. Objects (Part 8): Dynamic Typing
  29. Data Encapsulation
  30. Methods (In Detail)
  31. Pointers
  32. The Preprocessor
  33. Conditional Compilation
  34. Variable Scope
  35. Enumerated Types and typedefs
  36. Categories
  37. Protocols
  38. Memory Management
  39. Object Initialization
  40. Complex Initializers
  41. Exception Handling
  42. Key-Value Coding
  43. Advanced KVC
  44. Structs and Unions
  45. Structs and Objects
  46. Foreach Loop
  47. Mutable vs. Immutable Strings
  48. Floating in Uncertainty
  49. A Handy Debugging Tool
  50. Design Patterns: Model-View-Controller
  51. Cocoa Naming Conventions
  52. Design Patterns: Key-Value Observing
  53. Advanced Tables
  54. Rotation
  55. A Quartz Primer
  56. Adding Frameworks to an Xcode Project
  57. Building an App (Part 1): Basic UI Elements
  58. Building an App (Part 2): More UI Elements
  59. Building an App (Part 3): Flipping and Tab Bars
  60. Building an App (Part 4): Automatic Reference Counting
  61. Building an App (Part 5): Table Views and Nav Controllers
  62. Building an App (Part 6): Navigation Controllers and Stacks
  63. Building an App (Part 7): Quartz Demo 1
  64. Building an App (Part 8): Quartz Demo 2
  65. Building an App (Part 9): Quartz Demo 3
  66. Building an App (Part 10): Basic Data Persistence
  67. Building an App (Part 11): Core Data
  68. Building an App (Part 12): Working With Web Data

I might add a few to this list in the future – but this covers all of the basics and more. Stay tuned!

Author: Feifan Zhou