ਸ਼ਨੀਵਾਰ ਦੀ ਦੁਪਹਿਰ। ਤੁਸੀਂ ਕੌਫੀ ਨਾਲ ਬੈਠਦੇ ਹੋ, ਪੂਰੇ ਇਰਾਦੇ ਨਾਲ ਇੱਕ ਨਵਾਂ ਫੀਚਰ ਬਣਾਉਣ ਜਾਂ ਅਖੀਰਕਾਰ ਆਪਣੇ ਸਾਈਡ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਪਾਲਿਸ਼ ਕਰਨ ਲਈ। ਦਸ ਮਿੰਟਾਂ ਬਾਅਦ, ਸਭ ਕੁਝ ਰੁਕ ਜਾਂਦਾ ਹੈ। ਇਸ ਲਈ ਨਹੀਂ ਕਿ ਲੌਜਿਕ ਬਹੁਤ ਗੁੰਝਲਦਾਰ ਹੈ। ਇਸ ਲਈ ਨਹੀਂ ਕਿ ਤੁਹਾਨੂੰ ਫਰੇਮਵਰਕ ਦੀ ਸਮਝ ਨਹੀਂ ਹੈ। ਤਰੱਕੀ ਇਸ ਲਈ ਰੁਕ ਜਾਂਦੀ ਹੈ ਕਿਉਂਕਿ ਇੱਕ ਸਿੰਗਲ ਟੈਗ ਖੁੱਲ੍ਹਾ ਰਹਿ ਗਿਆ ਹੈ।

ਇਸੇ ਵੀਕੈਂਡ ਦੇ ਚੈਲੇਂਜ ਵਿੱਚ ਵੀ ਇਹੀ ਹੋਇਆ। ਇੱਕ Liquid ਸਿੰਟੈਕਸ ਐਰਰ (syntax error)। ਟੈਗ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਬੰਦ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ। ਪਾਰਸਰ (parser) ਫਾਈਲ ਵਿੱਚੋਂ ਲੰਘਿਆ, ਉਸ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚਿਆ ਜਿੱਥੇ ਉਸ ਨੂੰ ਇੱਕ ਕਲੋਜ਼ਿੰਗ ਸੀਕੁਐਂਸ (closing sequence) ਦੀ ਉਮੀਦ ਸੀ, ਅਤੇ ਉੱਥੇ ਕੁਝ ਵੀ ਨਹੀਂ ਮਿਲਿਆ। ਬੱਸ ਇੰਝ ਹੀ, ਬਿਲਡ ਫੇਲ ਹੋ ਗਿਆ। ਇਹ ਅਜਿਹਾ ਬੱਗ (bug) ਹੈ ਜੋ ਤਜਰਬੇਕਾਰ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਵੀ ਨਿਮਰ ਬਣਾ ਦਿੰਦਾ ਹੈ ਅਤੇ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਨੂੰ ਆਤਮ-ਵਿਸ਼ਵਾਸ ਦੀ ਕਮੀ ਵਿੱਚ ਧੱਕ ਸਕਦਾ ਹੈ, ਭਾਵੇਂ ਕਿ ਇੱਕ ਵਾਰ ਦੇਖ ਲੈਣ ਤੋਂ ਬਾਅਦ ਇਸ ਨੂੰ ਠੀਕ ਕਰਨ ਵਿੱਚ ਸਿਰਫ਼ ਕੁਝ ਸੈਕਿੰਡ ਲੱਗਦੇ ਹਨ।

ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ ਕੀ ਗਲਤ ਹੋਇਆ

Liquid ਇੱਕ ਟੈਂਪਲੇਟਿੰਗ ਭਾਸ਼ਾ ਹੈ ਜੋ Shopify ਦੁਆਰਾ ਬਣਾਈ ਗਈ ਹੈ, ਅਤੇ ਇਹ e-commerce ਸਟੋਰਫਰੰਟਸ ਤੋਂ ਲੈ ਕੇ GitHub Pages 'ਤੇ Jekyll-ਅਧਾਰਤ ਬਲੌਗਾਂ ਤੱਕ ਸਭ ਕੁਝ ਚਲਾਉਂਦੀ ਹੈ। ਇਹ ਦੋ ਮੁੱਖ ਸਿੰਟੈਕਸ ਪੈਟਰਨਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ। ਡਬਲ ਕਰਲੀ ਬਰੇਸ (double curly braces) ਆਊਟਪੁੱਟ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ {{ page.title }}। ਕਰਲੀ ਬਰੇਸ ਪਰਸੈਂਟ ਸਾਈਨ (curly brace percent signs) ਲੌਜਿਕ ਅਤੇ ਫਲੋਅ ਕੰਟਰੋਲ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ {% if user %} ਜਾਂ {% for item in list %}।

ਹਰ ਖੁੱਲ੍ਹੇ ਹੋਏ ਟੈਗ ਨੂੰ ਇੱਕ ਸਾਥੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਕ {% if %} ਲਈ {% endif %} ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਕ {% for %} ਲੂਪ ਲਈ {% endfor %} ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਕ ਕੈਪਚਰ ਬਲਾਕ (capture block) ਲਈ {% endcapture %} ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹ ਸਿਰਫ਼ ਸੁਝਾਅ ਨਹੀਂ ਹਨ। Liquid ਇੰਜਣ ਤੁਹਾਡੇ ਟੈਂਪਲੇਟ ਨੂੰ ਕ੍ਰਮਵਾਰ (sequentially) ਪੜ੍ਹਦਾ ਹੈ। ਜਦੋਂ ਇਹ ਕਿਸੇ ਖੁੱਲ੍ਹੇ ਹੋਏ ਕੰਸਟਰਕਟ (construct) ਨੂੰ ਦੇਖਦਾ ਹੈ, ਤਾਂ ਇਹ ਆਪਣੇ ਅੰਦਰੂਨੀ ਸਟੈਕ (stack) 'ਤੇ ਇੱਕ ਫਰੇਮ ਪਾ ਦਿੰਦਾ ਹੈ ਅਤੇ ਉਡੀਕ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਫਾਈਲ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ, ਜਾਂ ਜੇਕਰ ਉਮੀਦ ਕੀਤੇ ਗਏ ਟੈਗ ਦੇ ਦਿਖਾਈ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਕੋਈ ਹੋਰ ਵੱਡਾ ਬਲਾਕ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੰਜਣ ਐਰਰ ਦਿੰਦਾ ਹੈ। ਸੁਨੇਹਾ ਅਕਸਰ ਸਿੱਧਾ ਹੁੰਦਾ ਹੈ: tag was not closed correctly. ਸਿਸਟਮ ਨੇ ਇੱਕ ਕਲੋਜ਼ਿੰਗ ਸੀਕੁਐਂਸ ਦੀ ਉਮੀਦ ਕੀਤੀ ਸੀ। ਕਦੇ-ਕਦੇ ਤੁਹਾਨੂੰ ਲਾਈਨ ਨੰਬਰ ਮਿਲਦਾ ਹੈ। ਕਦੇ-ਕਦੇ ਉਹ ਲਾਈਨ ਨੰਬਰ ਗਲਤ ਜਗ੍ਹਾ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ ਪਾਰਸਰ ਨੂੰ ਉਦੋਂ ਤੱਕ ਇਹ ਅਹਿਸਾਸ ਨਹੀਂ ਹੁੰਦਾ ਕਿ ਉਸਦਾ ਸਾਥੀ ਟੈਗ ਗੁੰਮ ਹੈ ਜਦੋਂ ਤੱਕ ਉਹ ਇਸਦੇ ਹੇਠਾਂ ਦੀ ਸਾਰੀ ਚੀਜ਼ ਪੜ੍ਹ ਨਹੀਂ ਲੈਂਦਾ।

ਇੱਕ ਖਾਸ ਉਦਾਹਰਣ 'ਤੇ ਵਿਚਾਰ ਕਰੋ। ਤੁਸੀਂ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖ ਸਕਦੇ ਹੋ:

{% for product in collections.all.products %}
  <div class="card">
    <h2>{{ product.title }}</h2>
    {% if product.available %}
      <span>In stock</span>
    {% endif %}
  </div>
{% endfor %}

ਤਿੰਨੋਂ ਟੈਗ ਬੰਦ ਹਨ। ਹੁਣ ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਤੇਜ਼ੀ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਡਾਕੂਮੈਂਟੇਸ਼ਨ ਤੋਂ ਸਨਿਪੇਟਸ (snippets) ਕਾਪੀ ਅਤੇ ਪੇਸਟ ਕਰ ਰਹੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਅਚਾਨਕ ਅੰਤਿਮ r ਨੂੰ ਛੱਡ ਦਿੰਦੇ ਹੋ:

{% for product in collections.all.products %}
  <div class="card">
    <h2>{{ product.title }}</h2>
    {% if product.available %}
      <span>In stock</span>
  </div>
{% endfo %}

ਜਾਂ ਸ਼ਾਇਦ ਤੁਸੀਂ {% endfor %} ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਭੁੱਲ ਜਾਂਦੇ ਹੋ ਕਿਉਂਕਿ ਇਹ HTML ਦੀ ਇੱਕ ਲੰਬੀ ਲਾਈਨ ਦੇ ਹੇਠਾਂ ਹੁੰਦਾ ਹੈ। ਇੰਜਣ {% for % ਨੂੰ ਦੇਖਦਾ ਹੈ, ਲੂਪ ਨੂੰ ਰਜਿਸਟਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਕਦੇ ਵੀ ਇਸਦਾ ਸਾਥੀ ਨਹੀਂ ਲੱਭਦਾ। Shopify ਦੇ ਸੰਦਰਭ ਵਿੱਚ, ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਪੂਰਾ ਥੀਮ ਕੰਪਾਈਲ (compile) ਹੋਣ ਵਿੱਚ ਅਸਫਲ ਰਹਿੰਦਾ ਹੈ। Jekyll ਵਿੱਚ, GitHub Pages ਤੁਹਾਨੂੰ ਬਿਲਡ ਫੇਲ ਹੋਣ ਦਾ ਈਮੇਲ ਭੇਜਦਾ ਹੈ। ਲੋਕਲ ਡਿਵੈਲਪਮੈਂਟ ਵਿੱਚ ਇੱਕ ਅਜੀਬ ਸਟੈਕ ਟ੍ਰੇਸ (stack trace) ਦਿਖਾਈ ਦੇ ਸਕਦਾ ਹੈ। ਇੱਕ ਭੁੱਲਿਆ ਹੋਇਆ ਟੈਗ ਪੂਰੀ ਪਾਈਪਲਾਈਨ ਨੂੰ ਰੋਕ ਦਿੰਦਾ ਹੈ।

ਛੋਟੀਆਂ ਗਲਤੀਆਂ ਦਾ ਕਹਿਰ

ਇਹ ਗਲਤੀਆਂ ਬਹੁਤ ਗੁੱਸਾ ਦਿਵਾਉਂਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਇਹ ਗਲਤੀ ਦੇ ਆਕਾਰ ਦੇ ਅਨੁਸਾਰ ਨਹੀਂ ਵਧਦੀਆਂ। ਤੁਸੀਂ ਡਾਟਾਬੇਸ ਨੂੰ ਗਲਤ ਤਰੀਕੇ ਨਾਲ ਨਹੀਂ ਬਣਾਇਆ। ਤੁਸੀਂ ਗਲਤ ਐਲਗੋਰਿਦਮ (algorithm) ਨਹੀਂ ਚੁਣਿਆ। ਤੁਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਅੱਖਰ ਭੁੱਲ ਗਏ। ਛੋਟੀਆਂ ਗਲਤੀਆਂ ਵੱਡੇ ਬੱਗ (bugs) ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ। ਉਹ ਗੁੰਮ ਹੋਇਆ {% endif %} ਸਿਰਫ਼ ਇੱਕ ਲਾਈਨ ਨੂੰ ਨਿਮਰਤਾ ਨਾਲ ਨਹੀਂ ਤੋੜਦਾ। ਇਹ ਇੱਕ ਲੜੀ (cascade) ਬਣਾ ਦਿੰਦਾ ਹੈ। ਪਾਰਸਰ, ਜੋ ਹੁਣ ਇਸ ਗੱਲ ਬਾਰੇ ਉਲਝਿਆ ਹੋਇਆ ਹੈ ਕਿ ਕੰਡੀਸ਼ਨਲ (conditional) ਕਿੱਥੇ ਖਤਮ ਹੁੰਦਾ ਹੈ, ਹੇਠਾਂ ਦੀ ਹਰ ਲਾਈਨ ਨੂੰ ਗਲਤ ਮੰਨ ਸਕਦਾ ਹੈ। ਜੋ ਇੱਕ ਵੀਹ-ਲਾਈਨਾਂ ਦਾ ਟੈਂਪਲੇਟ ਲੱਗਦਾ ਹੈ, ਉਹ ਅਚਾਨਕ ਸੱਠ ਲਾਈਨਾਂ ਦਾ ਐਰਰ ਆਊਟਪੁੱਟ ਜਨਰੇਟ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚੋਂ ਜ਼ਿਆਦਾਤਰ ਗਲਤ ਹੁੰਦਾ ਹੈ।

ਤੁਸੀਂ ਇਹਨਾਂ ਗਲਤੀਆਂ ਦਾ ਸਾਹਮਣਾ ਉਦੋਂ ਕਰਦੇ ਹੋ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਅੱਖਰ ਭੁੱਲ ਜਾਂਦੇ ਹੋ, ਅਤੇ ਤੁਹਾਡਾ ਦਿਮਾਗ ਇਸ ਹਕੀਕਤ ਲਈ ਕਦੇ ਵੀ ਤਿਆਰ ਨਹੀਂ ਹੁੰਦਾ। ਇਨਸਾਨ ਪੈਟਰਨ ਪਛਾਣ (pattern recognition) ਰਾਹੀਂ ਕੋਡ ਪੜ੍ਹਦੇ ਹਨ। ਅਸੀਂ ਇਰਾਦੇ ਨੂੰ ਦੇਖਦੇ ਹਾਂ। ਅਸੀਂ if ਅਤੇ ਮਿਲਦੇ-ਜੁਲਦੇ ਲੌਜਿਕ ਨੂੰ ਦੇਖਦੇ ਹਾਂ ਅਤੇ ਅਸੀਂ ਸੀਮਾ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾ ਲੈਂਦੇ ਹਾਂ। ਕੰਪਿਊਟਰ ਅੰਦਾਜ਼ਾ ਨਹੀਂ ਲਗਾਉਂਦਾ। ਇਹ ਅੱਖਰ-ਦਰ-ਅੱਖਰ, ਉੱਪਰ ਤੋਂ ਹੇਠਾਂ ਤੱਕ, ਅੰਧ-ਅੰਧ (ambiguity) ਲਈ ਜ਼ੀਰੋ ਟੋਲਰੈਂਸ ਨਾਲ ਪੜ੍ਹਦਾ ਹੈ। ਜਦੋਂ ਇਹ ਸਾਥੀ ਟੈਗ ਦੀ ਉਡੀਕ ਕਰਦੇ ਹੋਏ ਫਾਈਲ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ, ਤਾਂ ਇਹ ਹਾਰ ਮੰਨ ਲੈਂਦਾ ਹੈ। ਤੁਹਾਡਾ ਕੰਮ ਅਜਿਹਾ ਡਿਵੈਲਪਰ ਬਣਨਾ ਹੈ ਜੋ ਖਾਲੀ ਥਾਂ ਨੂੰ ਲੱਭਣ ਲਈ ਕੁਝ ਸਮੇਂ ਲਈ ਪਾਰਸਰ ਵਾਂਗ ਸੋਚ ਸਕੇ।

ਇਹ ਸਿਰਫ਼ Liquid ਤੱਕ ਸੀਮਤ ਨਹੀਂ ਹੈ। Python ਵਿੱਚ ਇੱਕ ਅਣਖੁੱਲ੍ਹਾ ਬਰੈਕਟ (parenthesis), Markdown ਵਿੱਚ ਇੱਕ ਗੁੰਮ ਹੋਇਆ ਬੈਕਟਿਕ (backtick), JavaScript ਵਿੱਚ ਇੱਕ ਭੁੱਲਿਆ ਹੋਇਆ ਬਰੇਸ (brace), ਜਾਂ HTML ਵਿੱਚ ਇੱਕ ਲਟਕਦਾ ਹੋਇਆ ਐਂਗਲ ਬਰੈਕਟ (angle bracket)। ਵੀਕੈਂਡ ਚੈਲੇਂਜ ਨੇ ਸਿਖਾਉਣ ਲਈ Liquid ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਪਰ ਅਸਲ ਸਬਕ ਹਰ ਉਸ ਭਾਸ਼ਾ ਵਿੱਚ ਲਾਗੂ ਹੁੰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਕਦੇ ਵੀ ਵਰਤੋਗੇ। ਸਿੰਟੈਕਸ ਵਿਆਕਰਣ (grammar) ਹੈ, ਅਤੇ ਵਿਆਕਰਣ ਬੇਰਹਿਮ ਹੁੰਦੀ ਹੈ।

ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਲੱਭਿਆ ਜਾਵੇ

ਜਦੋਂ ਤੁਸੀਂ ਇਸ ਮੁਸ਼ਕਲ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਪਹਿਲੀ ਪ੍ਰਤੀਕਿਰਿਆ ਪੂਰੀ ਫਾਈਲ ਨੂੰ ਘਬਰਾ ਕੇ ਪੜ੍ਹਨ ਦੀ ਹੁੰਦੀ ਹੈ। ਇਸ ਤੋਂ ਬਚੋ। ਘਬਰਾ ਕੇ ਪੜ੍ਹਨ ਨਾਲ ਤੁਸੀਂ ਉਸ ਅਸਲ ਅੱਖਰ ਨੂੰ ਛੱਡ ਦਿੰਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਭੁੱਲ ਗਏ ਸੀ ਕਿਉਂਕਿ ਤੁਹਾਡਾ ਦਿਮਾਗ ਉਸਨੂੰ ਆਪਣੇ ਆਪ ਸਹੀ ਕਰ ਲੈਂਦਾ ਹੈ। ਇਸ ਦੀ ਬਜਾਏ, ਵਿਵਸਥਿਤ ਤਰੀਕੇ (systematically) ਨਾਲ ਕੰਮ ਕਰੋ।

ਆਪਣੇ ਟੈਗਸ ਨੂੰ ਸਪੱਸ਼ਟ ਰੂਪ ਵਿੱਚ ਮਿਲਾਓ। ਫਾਈਲ ਨੂੰ ਧਿਆਨ ਨਾਲ ਦੇਖੋ ਅਤੇ ਹਰ ਇੱਕ ਖੁੱਲ੍ਹਣ ਵਾਲੇ (opening) ਟੈਗ ਦਾ ਨਾਮ ਉੱਚੀ ਆਵਾਜ਼ ਵਿੱਚ ਜਾਂ ਕਾਗਜ਼ 'ਤੇ ਲਿਖੋ। for ਲਈ endfor ਦੀ ਲੋੜ ਹੈ। if ਲਈ endif ਦੀ ਲੋੜ ਹੈ। unless ਲਈ endunless ਦੀ ਲੋੜ ਹੈ। capture ਲਈ endcapture ਦੀ ਲੋੜ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਬਲਾਕਾਂ ਨੂੰ ਇੱਕ ਦੂਜੇ ਦੇ ਅੰਦਰ (nesting) ਰੱਖ ਰਹੇ ਹੋ, ਤਾਂ ਮਾਨਸਿਕ ਤੌਰ 'ਤੇ ਇੱਕ ਕਾਊਂਟਰ ਵਧਾਉਂਦੇ ਰਹੋ। ਜਦੋਂ ਮੈਂ ਇੱਕ for ਦੇ ਅੰਦਰ if ਖੋਲ੍ਹਦਾ ਹਾਂ, ਤਾਂ ਫਾਈਲ ਖਤਮ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਮੇਰੇ ਕੋਲ ਦੋ ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਮੈਨੂੰ ਪੂਰੀਆਂ ਕਰਨੀਆਂ ਹਨ।

ਆਪਣੇ ਐਡੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਜੇਕਰ ਤੁਸੀਂ ਨਿਯਮਤ ਰੂਪ ਵਿੱਚ Liquid ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਇੱਕ syntax highlighter ਇੰਸਟਾਲ ਕਰੋ ਜੋ ਵਿਆਕਰਣ (grammar) ਨੂੰ ਪਛਾਣ ਸਕੇ। Visual Studio Code ਵਿੱਚ ਅਜਿਹੇ extensions ਹਨ ਜੋ Liquid ਟੈਗਸ ਨੂੰ ਡਿਮ (dim) ਕਰ ਦਿੰਦੇ ਹਨ ਜਾਂ ਕਲਰ-ਕੋਡ ਕਰ ਦਿੰਦੇ ਹਨ। ਜਦੋਂ ਕੋਈ ਬੰਦ ਕਰਨ ਵਾਲਾ (closing) ਟੈਗ ਗਲਤ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਰੰਗ ਦਾ ਪੈਟਰਨ ਬਦਲ ਜਾਂਦਾ ਹੈ। ਕੁਝ linters ਕੰਪਾਈਲ (compile) ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਅਣਖੁੱਲ੍ਹੇ ਬਲਾਕਾਂ ਨੂੰ ਫੜ ਸਕਦੇ ਹਨ। Vim ਜਾਂ Neovim ਵਿੱਚ, vim-liquid ਵਰਗੇ ਪਲੱਗਇਨ 'ਤੇ ਵਿਚਾਰ ਕਰੋ ਜਾਂ ਮੈਚਿੰਗ ਟੈਗਸ ਨੂੰ ਹਾਈਲਾਈਟ ਕਰਨ ਲਈ Tree-sitter ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ। ਇਹ ਟੂਲ ਸੋਚਣ ਦੀ ਲੋੜ ਨੂੰ ਖਤਮ ਨਹੀਂ ਕਰਦੇ, ਪਰ ਇਹ ਗਲਤੀਆਂ ਨੂੰ ਸਾਫ਼ ਦਿਖਾਉਂਦੇ ਹਨ।

ਆਪਣੇ ਟੈਂਪਲੇਟ ਵਿੱਚ ਬਾਈਨਰੀ ਸਰਚ (Binary search) ਕਰੋ। ਜੇਕਰ ਐਰਰ ਮੈਸੇਜ ਲਾਈਨ 200 ਵੱਲ ਇਸ਼ਾਰਾ ਕਰ ਰਿਹਾ ਹੈ ਪਰ ਉੱਥੇ ਕੁਝ ਵੀ ਗਲਤ ਨਹੀਂ ਲੱਗ ਰਿਹਾ, ਤਾਂ ਅਸਲੀ ਗਲਤੀ ਸ਼ਾਇਦ ਉਸ ਤੋਂ ਉੱਪਰ ਹੈ। ਟੈਂਪਲੇਟ ਦੇ ਅੱਧੇ ਹਿੱਸੇ ਨੂੰ ਕਮੈਂਟ (comment) ਕਰ ਦਿਓ। ਕੀ ਇਹ ਬਿਲਡ ਹੁੰਦਾ ਹੈ? ਜੇਕਰ ਹਾਂ, ਤਾਂ ਐਰਰ ਕਮੈਂਟ ਕੀਤੇ ਹੋਏ ਹਿੱਸੇ ਵਿੱਚ ਹੈ। ਉਸ ਅੱਧੇ ਹਿੱਸੇ ਵਿੱਚੋਂ ਵੀ ਅੱਧਾ ਹਿੱਸਾ ਅਨਕਮੈਂਟ (uncomment) ਕਰੋ। ਇਸ ਨੂੰ ਉਦੋਂ ਤੱਕ ਦੁਹਰਾਓ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਖਰਾਬ ਬਲਾਕ ਨੂੰ ਵੱਖ ਨਹੀਂ ਕਰ ਲੈਂਦੇ। ਇਹ ਹੌਲੀ ਲੱਗ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਉਹੀ 200 ਲਾਈਨਾਂ ਨੂੰ ਛੇ ਵਾਰ ਪੜ੍ਹਨ ਨਾਲੋਂ ਤੇਜ਼ ਹੈ ਜਦੋਂ ਤੁਹਾਡੀ ਨਿਰਾਸ਼ਾ ਵਧ ਰਹੀ ਹੋਵੇ।

ਆਪਣੇ includes ਦੀ ਜਾਂਚ ਕਰੋ। Liquid {% include %} ਜਾਂ {% render %} ਰਾਹੀਂ ਮੋਡਿਊਲਰ ਫਰੈਗਮੈਂਟਸ (modular fragments) ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਅਣਖੁੱਲ੍ਹਾ ਟੈਗ ਸ਼ਾਇਦ ਮੁੱਖ ਫਾਈਲ ਵਿੱਚ ਹੋਵੇ ਹੀ ਨਾ। ਇਹ ਕਿਸੇ ਅਜਿਹੇ ਸਨਿਪੇਟ (snippet) ਦੇ ਅੰਦਰ ਹੋ ਸਕਦਾ ਹੈ ਜਿਸ ਨੂੰ ਮੇਨ ਟੈਂਪਲੇਟ ਵਿੱਚ ਵਰਤਿਆ ਗਿਆ ਹੋਵੇ। ਇੱਥੇ ਹੀ version control ਤੁਹਾਡੀ ਮਾਨਸਿਕ ਸ਼ਾਂਤੀ ਬਚਾਉਂਦਾ ਹੈ। ਇੱਕ diff ਚਲਾਓ। ਦੇਖੋ ਕਿ ਆਖਰੀ ਸਫਲ ਬਿਲਡ ਤੋਂ ਬਾਅਦ ਕੀ ਬਦਲਿਆ ਹੈ। ਅਕਸਰ ਜਵਾਬ ਲਾਲ ਅਤੇ ਹਰੇ ਰੰਗ ਵਿੱਚ ਸਾਫ਼ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।

ਇੰਡੈਂਟੇਸ਼ਨ (Indentation) ਹੀ ਦਸਤਾਵੇਜ਼ ਹੈ। ਜੇਕਰ ਤੁਹਾਡਾ {% if %} ਕਾਲਮ ਜ਼ੀਰੋ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸਦਾ ਸੰਬੰਧਿਤ {% endif %} ਕਿਸੇ ਅੰਦਰਲੇ (nested) ਢਾਂਚੇ ਦੇ ਅੰਦਰ ਇੰਡੈਂਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਵਿਜ਼ੂਅਲ ਅਲਾਈਨਮੈਂਟ ਤੁਹਾਨੂੰ ਗਲਤੀ ਨੂੰ ਨੋਟ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੇ HTML ਅਤੇ Liquid ਟੈਗਸ ਇੱਕੋ ਜਿਹੀ ਇੰਡੈਂਟੇਸ਼ਨ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, ਤਾਂ ਤੁਹਾਡੀਆਂ ਅੱਖਾਂ ਗਲਤ ਡੂੰਘਾਈ 'ਤੇ ਬੈਠੇ ਟੈਗ ਨੂੰ ਫੜ ਲੈਣਗੀਆਂ।

ਅਸਲੀ ਕਰੀਕੁਲਮ (The Real Curriculum)

ਵੀਕੈਂਡ ਚੁਣੌਤੀਆਂ ਮਹੱਤਵਪੂਰਨ ਹਨ ਕਿਉਂਕਿ ਉਹ ਬਿਲਕੁਲ ਉਨ੍ਹਾਂ ਹਾਲਤਾਂ ਦੀ ਨਕਲ ਕਰਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹੋ। ਕੋਈ ਮੈਨੇਜਰ ਨਹੀਂ ਦੇਖ ਰਿਹਾ। ਕੋਈ ਡੈੱਡਲਾਈਨ ਦਾ ਦਬਾਅ ਨਹੀਂ ਹੈ। ਤੁਸੀਂ ਹੁਨਰ ਜਾਂ ਮਨੋਰੰਜਨ ਲਈ ਕੋਡਿੰਗ ਕਰ ਰਹੇ ਹੋ, ਅਤੇ ਫਿਰ ਇੱਕ ਬਹੁਤ ਹੀ ਛੋਟੀ ਜਿਹੀ ਗਲਤੀ ਤੁਹਾਨੂੰ ਰੋਕ ਦਿੰਦੀ ਹੈ। ਉਹੀ ਪਲ ਇੱਕ ਸਬਕ ਹੈ। ਤੁਸੀਂ ਡੀਬੱਗਿੰਗ (debugging) ਬਾਰੇ ਪੜ੍ਹ ਕੇ ਡੀਬੱਗ ਕਰਨਾ ਨਹੀਂ ਸਿੱਖਦੇ। ਤੁਸੀਂ ਇੱਕ ਖਰਾਬ ਬਿਲਡ ਨੂੰ ਲਗਾਤਾਰ ਦੇਖ ਕੇ ਸਿੱਖਦੇ ਹੋ ਜਦੋਂ ਕਿ ਤੁਸੀਂ ਬਾਹਰ ਜਾਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਅਤੇ ਆਪਣੇ ਆਪ ਨੂੰ ਇੱਕ ਐਰਰ ਮੈਸੇਜ ਨੂੰ ਨਿਖੇਧੀ (criticism) ਦੀ ਬਜਾਏ ਡੇਟਾ ਵਜੋਂ ਲੈਣ ਲਈ ਮਜਬੂਰ ਕਰਦੇ ਹੋ।

ਇਹਨਾਂ ਗਲਤੀਆਂ ਨੂੰ ਸੁਧਾਰਨਾ ਸਿੱਖੋ ਕਿਉਂਕਿ ਇਹ ਕਦੇ ਵੀ ਪੂਰੀ ਤਰ੍ਹਾਂ ਖਤਮ ਨਹੀਂ ਹੁੰਦੀਆਂ। ਕਰੀਅਰ ਦੇ ਦਸ ਸਾਲਾਂ ਬਾਅਦ ਵੀ, ਤੁਸੀਂ ਸ਼ੁੱਕਰਵਾਰ ਦੀ ਰਾਤ ਨੂੰ ਡਿਪਲਾਈ (deploy) ਕਰਦੇ ਸਮੇਂ ਇੱਕ ਕਲੋਜ਼ਿੰਗ ਟੈਗ ਭੁੱਲ ਸਕਦੇ ਹੋ। ਇੱਕ ਜੂਨੀਅਰ ਅਤੇ ਇੱਕ ਸੀਨੀਅਰ ਡਿਵੈਲਪਰ ਵਿਚਕਾਰ ਅੰਤਰ ਗਲਤੀਆਂ ਦੀ ਗੈਰ-ਮੌਜੂਦਗੀ ਨਹੀਂ ਹੈ। ਇਹ ਰਿਕਵਰੀ (recovery) ਦੀ ਰਫ਼ਤਾਰ ਹੈ। ਸੀਨੀਅਰ ਸਿੰਟੈਕਸ ਐਰਰ ਨੂੰ ਦੇਖਦਾ ਹੈ, ਪੈਟਰਨ ਨੂੰ ਪਛਾਣਦਾ ਹੈ, ਸਪੱਸ਼ਟ ਸ਼ੱਕੀ ਚੀਜ਼ਾਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਅੱਗੇ ਵਧ ਜਾਂਦਾ ਹੈ। ਜੂਨੀਅਰ ਸੋਚਦਾ ਹੈ ਕਿ ਕੀ ਪੂਰਾ ਟੂਲਚੇਨ (toolchain) ਹੀ ਖਰਾਬ ਹੈ। ਦੁਹਰਾਓ (Repetition) ਉਸ ਰਿਫਲੈਕਸ ਨੂੰ ਬਣਾਉਂਦਾ ਹੈ।

ਭਾਈਚਾਰਕ ਪੱਖ (community aspect) ਇਸ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਕਈ ਲੋਕ ਵੀਕੈਂਡ ਦੌਰਾਨ ਇੱਕੋ ਜਿਹੇ ਖਰਾਬ ਟੈਂਪਲੇਟ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹਨ, ਤਾਂ ਅਜਿਹੇ ਪੈਟਰਨ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ ਜੋ ਕੋਈ ਵੀ ਇਕੱਲਾ ਡਿਵੈਲਪਰ ਨਹੀਂ ਦੇਖ ਸਕਦਾ। ਕੋਈ ਨੋਟ ਕਰਦਾ ਹੈ ਕਿ ਐਰਰ ਸਿਰਫ਼ ਨੇਸਟਡ (nested) for ਲੂਪਸ ਦੇ ਅੰਦਰ ਹੀ ਆਉਂਦੀ ਹੈ। ਕੋਈ ਹੋਰ ਇੱਕ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ (shell script) ਸਾਂਝੀ ਕਰਦਾ ਹੈ ਜੋ ਆਮ Liquid ਟੈਗ ਮਿਸਮੈਚਾਂ ਲਈ grep ਕਰਦੀ ਹੈ। ਗਿਆਨ ਉਦੋਂ ਵਧਦਾ ਹੈ ਜਦੋਂ ਇਸ ਦਾ ਆਦਾਨ-ਪ੍ਰ