A better approach
Focus on a single learning project at a time
- Learning new complex topic is already hard, and you’ll make it a lot harder if you try to learn many different things at once.
- Especially, if you have a full-time job try to focus on a single topic. This approach will increase your chance to finish it in a foreseeable future.
- Trying to learn many new things at once will probably result in frustration, and you will end up failing at all of them.
Create learning plan
- To succeed you need to start with a clear S.M.A.R.T (Specific. Measurable. Achievable. Relevant. Time-boxed.) end goal in your mind.
- An example of a bad goal: “I want to learn Clojure and ClojureScript”
- An example of a better goal: “I’ll learn enough of Clojure, ClojureScript and web development libraries so that I can build the first version of a non-trivial Clojure web application with REST API and simple UI within three months”
- Here I’m playing with an idea to create My Bookshelf application for simple book management (I love books).
- Another key point to realize is that you don’t need to achieve mastery in everything you want to learn. Try to always identify the desired level from 1-10 (1 – very basic overview; 10 – mastery).
- More details later in section 10-step learning process
Execute the plan on a daily basis
- A consistent, deliberate practice is essential for success
- Ideas are easy, Implementation is hard (Guy Kawasaki: http://www.forbes.com/2004/11/04/cx_gk_1104artofthestart.html)
- Reserve at least 0.5 h each day for mastering new skill
- The minimal duration can vary, but I’d rather recommend spending at least 1 hour working on your project each day
- Work on each step in iterations until you finish all steps – one step at a time
- Two tasks daily rule
- one repeating task
- one task from a project list
- Pick one task from your project and try to complete it.
- For example: “Create a project structure for My Bookshelf application. Create git repository and push the skeleton.”
- Focus on practical experience rather than just cramming a huge amount of information from books and the internet into (and out of) your head
- Create a learning project to practice everything you want to learn
Example of 10-step learning process
Step 1: Get the big Picture – 50,000 ft view
- I’ve already written some Clojure/ClojureScript code in the past and read lots of articles and Living Clojure book.
- Following are my observations:
- I know what I want to do: Create a web application for book management.
- I know what other options I have (GoodReads, Libib, etc.) but none of these options seems to be suitable for my needs.
- I know a little bit of Clojure/ClojureScript so I can get started.
Step 2: Determine the scope of what you want to learn
- I want to build a real application that I can use for my own book management.
- I’ve identified various features – this will be an ongoing project.
- I even have Trello board for tasks related to this project
- As a first milestone, I want to implement MVP using some libraries mentioned in Web Development with Clojure book.
- I want to embrace REPL driven development combined with TDD – I’ll write a lot of tests.
Step 3: Define how the success will look like
- My Bookshelf is up and running (at least on my local computer) and I’m able to add new books to bookshelf database, update or delete existing book, list all books, show book detail.
- MUST-HAVE: basic attributes like “Title”, “Author”, “Year”, and “Status” (to distinguish books which I want to read/buy and those which I’ve already read/bought)
- COULD-HAVE: further attributes can be added if useful for practical usage
- NICE-TO-HAVE: the ability to search books by keywords on Amazon, show the results and be able to select the book which I want to add.
- Book database is persisted across different runs of the application.
- There’s at least primitive UI which can show me a list of books that I’ve added.
- I have an automated acceptance test checking the supported features.
Step 4: Find resources
- Probably not in the first iteration, but I definitely want to learn Clojure.spec and used it in my application
- Introduction to clojure.spec – talk by Arne Brasseur on ClojureTRE 2016
- Intro to clojure.spec https://lambdaisland.com/episodes/clojure-spec
- Check also: https://vimeo.com/195711510
(Rich Hickey on Clojure Spec)
- Stuart Halloway screencast series: https://www.youtube.com/playlist?list=PLZdCLR02grLrju9ntDh3RGPpWSWBvjwXg
- Excellent demonstrations of spec capabilities
- re-frame tutorial
- Real-world project examples
- Karel Miarka’s project: https://github.com/kajism/liskasys
- series of tutorials on ClojureScript: https://github.com/magomimmo/modern-cljs
- can be used for a quick check if there’s a better solution for the problems I have in the implementation of client side of my project
Step 5: Create a learning plan
- DONE. Define learning strategy & resources
- Read the first parts of Clojure applied and Web Development with Clojure, 2nd ed. to know how to start
- Create application skeleton – client and server part -> Display hello world
- Create the first draft of application domain; in-memory store
- Write some tests
- Primitive read-only UI showing the book list
- Persist entities to survive application restart
- UI for adding a new book
- UI for updating & deleting existing books
- Redesign domain/data model based on recent experience
- Use Clojure.spec?
- Add possibility to store details (notes) about the book
- Book tags
- Add basic search
- Track/watch books
- Iterate adding new features; evaluating different options/libraries/frameworks
Step 6: Filter the resources
Most important resources from step 4. Find resources:
Step 7: Learn enough to get started
One example could be Reading the first chapter in Web Development with Clojure, 2nd ed. and then generating new project structure from leiningen template.
Step 8: Play around
For example: Examine the application skeleton generated in the previous step and play with the application in REPL. Try to execute some DB queries and make sure you are familiar with each important part of the project structure.
Step 9: Learn enough to do something useful
The result of this step should be adding a new feature to your project, e.g. Implementation of “Add a New Book” feature.
Step 10: Teach
Teach what you learned to others. This is a great way to make sure you have a solid understanding of the material you’ve learned. The other persons can be your colleagues, friends, local meetup group, readers of your blog, or even your spouse.
- Identify your learning style
- Different people tend to favor different learning styles – social, solitary, visual, aural, verbal, physical, logical.
- Try to identify 2-3 learning styles which suit you best and embrace them.
- Pick a skill you’d like to master
- Choose a single skill – identify #1 goal you’d like to accomplish.
- Focus on one skill at a time.
- Pick your desired level of expertise.
- Build the learning habit
- The quickest path to skill mastery is to focus on this area completely.
- Focus on daily training.
- Practice just-in-time learning – research information related to the next step, ignore everything else.
- Take actionable notes
- Check out Cornell Method. It’s a very useful way to capture, understand and review a learning material.
- Build a project around a skill
- In order to learn something, you need to practice it.
- Create a real-world project for the skill you want to master and apply the things you’ve learned in the project.
- Deliberate practice
- Deliberate practice is the most important thing; talent is usually of minor importance.