<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by lulu2k2 on Medium]]></title>
        <description><![CDATA[Stories by lulu2k2 on Medium]]></description>
        <link>https://medium.com/@lulu2k2?source=rss-5277201fa2c9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*63KoulU0jF6zRFqP5hV1BQ.jpeg</url>
            <title>Stories by lulu2k2 on Medium</title>
            <link>https://medium.com/@lulu2k2?source=rss-5277201fa2c9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 04:38:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@lulu2k2/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[SV Assertions Chapter 002]]></title>
            <link>https://lulu2k2.medium.com/sv-assertions-chapter-002-d562dd9a598f?source=rss-5277201fa2c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/d562dd9a598f</guid>
            <category><![CDATA[vlsi-verification]]></category>
            <category><![CDATA[hardware-verification]]></category>
            <dc:creator><![CDATA[lulu2k2]]></dc:creator>
            <pubDate>Tue, 11 Aug 2026 22:13:07 GMT</pubDate>
            <atom:updated>2026-08-11T22:13:07.275Z</atom:updated>
            <content:encoded><![CDATA[<p>Let’s continue with writing some basic assertions. You can write them in different forms. We will discuss each one and why to use them in the first place.</p><p><strong>Immediate assertions</strong>: You can write them directly with your design or in procedural blocks. These are similar to if statements; they are instantaneous and are only active within the block.</p><pre>always @(posedge clk)<br>  assert !(wr_en &amp;&amp; rd_en);<br><br>//this is equivalent to<br><br>always @(posedge clk)<br>  if (wr_en &amp;&amp; rd_en)<br>    $display(&quot;error&quot;);</pre><p>In these immediate assertions, we have different types. The one above is a <strong>simple immediate assertion</strong>.</p><p>The we have <strong>deferred immediate assertions</strong>: It is just writing with “<strong>#0</strong>” (inactive region) or “<strong>final</strong>” so to evaluate in the postponed region.</p><pre>always @(posedge clk)<br>  assert #0 !(wr_en &amp;&amp; rd_en);<br><br>or<br><br>always @(posedge clk)<br>  assert final !(wr_en &amp;&amp; rd_en);</pre><p>Why? Because it allows us to deal with glitches on combination signals in simulation. These are for simulations. Not required for formal verification.</p><p><strong>Concurrent assertions</strong>: These are the SVA used in industry. As we discussed earlier, we write properties, aka rules. We will discuss these later in depth. These just sit and monitor; you can write temporal logics (sequential logic to keep it simple).</p><p>To remember easily, in simulations</p><ul><li><strong>simple immediate</strong>: sampled in active region</li><li><strong>concurrent</strong>: sampled in preponed region</li><li><strong>#0 deferred</strong>: sampled in inactive region</li><li><strong>final deferred</strong>: sampled in postponed region</li></ul><p>Ok, if that’s clear, now we can go ahead with deep diving into concurrent assertions. Syntax might look scary, but just remember what we have discussed: we write properties, and we tell the tool what to do with the property.</p><pre>rw_chk : assert property (@(posedge clk) disable iff (!rst_n) !(wr_en &amp;&amp; rd_en));</pre><p>Let&#39;s dissect this line. First, “<strong>rw_chk</strong>” is just the name of our assertion. Then, our tool keyword is “<strong>assert</strong>,” so we are telling the tool to check if this property is being held true or not. So, we tell the tool to check at every clk posedge. Next is “<strong>disable iff (!rst_n)</strong>” which is telling the tool, whenever <strong>rst_n</strong> is low, don’t mind the rule. Ignore it. Our rule is not required to be checked when there is a reset. Next, “<strong>!(wr_en &amp;&amp; rd_en)</strong>” is just our main rule.</p><p>There are some ways you can write these checkers, but essentially everything means the same; it’s just for readability, I guess.</p><pre>rule_name : assert property (our_property)</pre><p>You can write the rules separately and just write like the above line.</p><pre>property rw_p;<br>  !(wr_en &amp;&amp; rd_en);<br>endproperty<br><br>rw_chk : assert property (@(posedge clk) disable iff (!rst_n) rw_p);</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d562dd9a598f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SV Assertions Intro Chapter-001]]></title>
            <link>https://lulu2k2.medium.com/sv-assertions-intro-chapter-001-e2206e0edca2?source=rss-5277201fa2c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/e2206e0edca2</guid>
            <category><![CDATA[formal-verification]]></category>
            <category><![CDATA[vlsi]]></category>
            <category><![CDATA[vlsi-verification]]></category>
            <dc:creator><![CDATA[lulu2k2]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 21:45:21 GMT</pubDate>
            <atom:updated>2026-08-05T00:35:25.574Z</atom:updated>
            <content:encoded><![CDATA[<p>We will see why we need to write assertions and how it makes our verification very easy. We will also see some downsides of it.</p><p>There are 2 types of writing SVA.</p><ol><li>SVA for formal and simulation</li><li>SVA for only simulation</li></ol><p>We will discuss why in later parts. For now, we will focus on what assertions are and how to write them.</p><h3>What is an assertion?</h3><p>It&#39;s an embedded checker in your code.</p><p>During verification, assertions monitor :</p><ul><li>If a specific condition occurs, or</li><li>If a specific sequence of events occurs</li></ul><p>Assertions generate warnings or errors when:</p><ul><li>A specified condition fails, or</li><li>A specified sequence does not complete properly.</li></ul><p>They offer many advantages to the designers in finding bugs earlier and more easily.</p><p><strong>We basically write properties that our design should never violate.</strong></p><p>So what is a property? It&#39;s a collection of logical and temporal relationships between boolean expressions, sequential expressions, and other properties that represent a set of behaviors. We will see what each word means in subsequent parts of this chapter.</p><p>Another important keyword is cover. Cover is similar to what you might have learnt in SV: coverage. Here, cover, to be specific, means whether a sequence of normal design behaviour has been observed or not. For example, cases like my FIFO has been emptied and filled again.</p><p>In <strong>simulation</strong>, it&#39;s similar to coverage. It counts how many times this sequence was observed. In <strong>formal </strong>terms, it just tells whether the particular sequence(think of it like a set of events in our design) was observed or not.</p><p>It&#39;s always better to start writing assertions when you start building basic components of the design. As they will be small and easy to verify.</p><p>SVA is definitely awesome, but it comes at a very high cost.</p><ul><li>When you write incorrect assertions, it is just difficult to debug. Incorrect assertions might hide bugs in your design.</li><li>We don’t know how many assertions are good enough. We don’t know when to stop.</li><li>Simulation overhead.</li><li>It&#39;s kind of not really good for large designs. For larger designs, the state space for exploration explodes. There is a way to reduce the state space for exploration, but it doesnt always work, and you need to be careful.</li></ul><p>Ok, now let&#39;s see some important terminology.</p><p><strong>Invariant</strong>: A boolean condition that should always hold true.</p><p>Example: A and B are never both high. At every moment, the condition must be true.</p><p>(A &amp; B) == True</p><p><strong>Temporal sequence</strong>: A series of boolean conditions evaluated over time. A sequence of length 1 is the same as a Boolean.</p><p>Example: If A is high in cycle 1, then B must be high in cycle 2, and then C must be high in the next cycle. This is a sequence of events that should be held true.</p><p>A -&gt; B -&gt; C</p><p><strong>Property</strong>: It&#39;s just the rule as we discussed earlier. It can be built with many invariants or sequences.</p><p>Now coming back to assertion, it is nothing but saying to check this property or monitor this property. It is just like a tool that checks the rule.</p><pre>property P1;<br>  A |-&gt; ##1 B;<br>endproperty</pre><pre>assert property (P1);</pre><p>No need to know what the syntax is for now; just see what we are doing here. We wrote a property that our design should follow. Well and good. But we need to tell the tool to monitor or check whether this property is being violated or not. If it&#39;s being held true, good. If not throw an error message or stop the simulation, so that we don’t have to wait for long simulation runs. You don’t have to write error messages; there will be default prints that happen when these fail, but you can still write your own messages.</p><p>For now, just remember: <strong>property </strong>is where we write our rules.</p><p>If, until now, everything is clear, we will move to the next set of main keywords. These are verification directive keywords that tell the tool what to do with the properties.</p><pre>assert</pre><p><strong>assert</strong>: this keyword with our property tells the tool, yo!! monitor this property if it&#39;s being held true or not.</p><pre>assume</pre><p><strong>assume</strong>: An assumption or a constraint. You say to the tool, take this property or inputs and assume this is always true. As I told you earlier, we need to restrict our state space so it won’t explode; we use this keyword to reduce the variables to check. In simulation, this doesn’t make any sense, so it converts into an assertion.</p><pre>cover</pre><p><strong>cover</strong>: same as what we discussed earlier; we tell the tool to check if this property has been exercised or not. In other words, demonstrate that it is possible for the expression to be true. Why do you need this? Because you need to see if scenarios are exercisable or not. Again, it has 2 meaning based on usage. In simulation, it just says how many times the property has been covered, similar to coverage (in simulation, we use stimulus, so we need to know the count). In formal verification, the tool just tests with all possible input values, so this cover will tell if there exists a sequence of inputs for making this property true at least once.</p><p>There is another keyword called “<strong>restrict</strong>”, which is basically the same as assume; it’s just a readability intent statement. The only difference is that, in simulation, it’s ignored.</p><p>These may look super hard to understand and look like English grammar, but just remember:</p><ul><li><strong>property</strong>: our rule</li><li><strong>assert, assume, cover</strong>: tell the tool what to do with the property. Monitor to see if it has failed? Just check if it holds for any inputs? Or just assume it is always true?</li></ul><p>That’s it for chapter 1; we will dive deeper in later chapters.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2206e0edca2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[UVM tutorial for beginners (Part 001)]]></title>
            <link>https://lulu2k2.medium.com/uvm-tutorial-for-beginners-part-001-07380470e9b4?source=rss-5277201fa2c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/07380470e9b4</guid>
            <category><![CDATA[hardware-verification]]></category>
            <category><![CDATA[vlsi-verification]]></category>
            <category><![CDATA[testbenches]]></category>
            <category><![CDATA[vmu]]></category>
            <dc:creator><![CDATA[lulu2k2]]></dc:creator>
            <pubDate>Sun, 28 Jun 2026 17:12:48 GMT</pubDate>
            <atom:updated>2026-06-28T17:12:48.706Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lbplOVoPrZtWxcZV.png" /><figcaption>UVM Testbench architecture (src: OpenDV)</figcaption></figure><p>I will be starting a UVM tutorial series that covers why something is written as it is. We will slowly build up on some core concepts of verification and eventually make a small VIP.</p><p><em>These will not be LLM-generated notes, so rest assured.</em></p><p>The tools I will be using are <strong>VS Code</strong> (editor and some extensions to support the language highlighting), <strong>Xilinx Vivado</strong> (free license, doesn’t support all constructs, but it&#39;s enough for now). You can also use the <strong>eda playground</strong>. Also, I am hoping that you have an idea of object-oriented programming in SystemVerilog.</p><p><strong>Why do we need UVM?</strong> <strong>Why can’t we simply use a Verilog/SystemVerilog testbench?</strong></p><p>The simple answer is scalability. The UVM library provides us with a huge set of predefined items; we don’t have to write everything from scratch. It helps us reuse our code for various projects. One can add many tests on top of the existing implementation.</p><p>Just imagine a situation, you joined a company where they have already built and are using a verification IP for a long time. It is working fine. Now, any company builds new features on top of the existing design. Do you start writing all of the testbench from scratch? No, that would be a waste of time. So what do you do? You start by building additional test cases to verify the new features on top of the existing VIP. UVM gives the freedom to easily work on existing testbenches without disturbing the already working code (I slightly oversimplified, but we will get to it later). So it has become an industry standard.</p><p>As of now, we are not working on an existing VIP, and we are trying to build one. We will start by building our transaction. Remember this: for building a large testbench, we don’t want to use individual signals everywhere. It will be a nightmare for writing/reading the testbench. So, instead of passing individual signals around the testbench, we encapsulate the signal values into transactions and work with transaction objects.</p><p>A transaction is essentially a class that represents a protocol operation or a packet containing fields corresponding to the DUT inputs/outputs. Why is it required? Because it is easier to just use the transaction object all over the place in the UVM testbench rather than using individual input and output signals.</p><p>Ok, that&#39;s about the little introduction. We will now see how to write our transaction class.</p><p>We will build a simple UVM TB for an unsigned adder. A very basic one, just 2 inputs and 1 output.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/424/1*dcCi63Dq7AbAQ-rCBOmzeA.png" /><figcaption><strong>Adder</strong></figcaption></figure><pre>module adder<br>  (<br>  input                clk     ,<br>  input          [15:0] A_in   ,<br>  input          [15:0] B_in   ,<br>  output logic   [16:0] Sum_out,<br><br>  input                rst<br>  );<br><br><br>  always_ff @(posedge clk or posedge rst)<br>    if(rst) begin<br>    Sum_out &lt;= &#39;b0;<br>  end else begin<br>    Sum_out &lt;= A_in + B_in;<br>    end<br><br>endmodule</pre><p><strong>The UVM architecture we will use here is as follows</strong> <strong>:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A3oVogWujm1oYTtBvYqGyA.png" /></figure><p>You could technically have 2 agents, one active, another passive (we will get to this later). But to keep things simple for the introduction, I will be using the above architecture containing only 1 agent.</p><p>Let’s end part 001 by discussing sequence_item, aka our transaction class.</p><pre>class adder_sequence_item extends uvm_sequence_item;<br><br>    //inputs and outputs<br>    rand logic [15:0] A_in;<br>    rand logic [15:0] B_in;<br><br>    logic [16:0] Sum_out;<br>    rand logic rst;<br>    //////////////////////<br><br>    //Factory registration<br>    `uvm_object_utils_begin(adder_sequence_item)<br>    `uvm_field_int(A_in, UVM_ALL_ON)<br>    `uvm_field_int(B_in, UVM_ALL_ON)<br>    `uvm_field_int(Sum_out, UVM_ALL_ON)<br>    `uvm_field_int(rst, UVM_ALL_ON)<br>    `uvm_object_utils_end<br>    //Factory registration done<br><br><br>    function new(string name = &quot;adder_sequence_item&quot;);<br>        super.new(name);<br>    endfunction : new<br><br>    //constraints if you want<br><br><br>endclass : adder_sequence_item</pre><p>So this is our transaction: the UVM library provides a class called <strong>“uvm_sequence_item,”</strong> which we extend to create our own transaction.</p><pre>// @uvm-ieee 1800.2-2020 auto 14.1.1<br>class uvm_sequence_item extends uvm_transaction;<br><br>  local      int                m_sequence_id = -1;<br>  protected  bit                m_use_sequence_info;<br>  protected  int                m_depth = -1;<br>  protected  uvm_sequencer_base m_sequencer;<br>  protected  uvm_sequence_base  m_parent_sequence;<br>  static     bit issued1,issued2;<br>  bit        print_sequence_info;<br><br><br>  // Function -- NODOCS -- new<br>  //<br>  // The constructor method for uvm_sequence_item. <br>  <br>  // @uvm-ieee 1800.2-2020 auto 14.1.2.1<br>  function new (string name = &quot;uvm_sequence_item&quot;);<br>    super.new(name);<br>  endfunction<br><br>  function string get_type_name();<br>    return &quot;uvm_sequence_item&quot;;<br>  endfunction <br><br>  // Macro for factory creation<br>  `uvm_object_registry(uvm_sequence_item, &quot;uvm_sequence_item&quot;)</pre><p>The above code is a snippet from the actual UVM library (uvm_sequence_item.svh)</p><p>The “adder_sequence_item” class is extended from this class. We can see that its constructor accepts a string as an optional input. So that&#39;s the reason we write this in our transaction class.</p><pre>    function new(string name = &quot;adder_sequence_item&quot;);<br>        super.new(name);<br>    endfunction : new</pre><p>As for the UVM macros :</p><pre>`define uvm_field_utils_begin(T)                                                \<br>function void do_execute_op( uvm_field_op op );                                 \<br>  super.do_execute_op(op);                                                      \<br>  __m_uvm_execute_field_op(op);                                                 \<br>endfunction : do_execute_op                                                     \<br>local function void __m_uvm_execute_field_op( uvm_field_op __local_op__ );      \<br>   uvm_field_flag_t local_op_type__; /* Used to avoid re-querying */            \<br>   T local_rhs__; /* Used for $casting copy and compare */                      \<br>   uvm_resource_base local_rsrc__; /* Used for UVM_SET ops */                   \<br>   string local_rsrc_name__;                                                    \<br>   uvm_object local_obj__; /* Used when trying to read uvm_object resources */  \<br>   bit local_success__; /* Used when trying to read resources */                \<br>   typedef T __local_type__; /* Used for referring to type T in field macros */ \<br>   int local_size__; /* Used when unpacking size values */                      \<br>   /* All possible policy classes */                                            \<br>   /* Using the same name as the do_* methods, allows macro reuse */            \<br>   uvm_printer __local_printer__;                                               \<br>   uvm_comparer __local_comparer__;                                             \<br>   uvm_recorder __local_recorder__;                                             \<br>   uvm_packer __local_packer__;                                                 \<br>   uvm_copier __local_copier__;                                                 \<br>   uvm_queue#(uvm_acs_name_struct) __local_field_names__;                       \<br>   void&#39;($cast(local_rhs__, __local_op__.get_rhs()));                           \<br>   if (($cast(local_rsrc__, __local_op__.get_rhs())) &amp;&amp;                         \<br>       (local_rsrc__ != null))                                                  \<br>     local_rsrc_name__ = local_rsrc__.get_name();                               \<br>   local_op_type__ = __local_op__.get_op_type();                                \<br>   case (local_op_type__)                                                       \<br>     UVM_PRINT: begin                                                           \<br>       $cast(__local_printer__, __local_op__.get_policy());                     \<br>     end                                                                        \<br>     UVM_COMPARE: begin                                                         \<br>       if (local_rhs__ == null) return;                                         \<br>       $cast(__local_comparer__, __local_op__.get_policy());                    \<br>     end                                                                        \<br>     UVM_RECORD: begin                                                          \<br>       $cast(__local_recorder__, __local_op__.get_policy());                    \<br>     end                                                                        \<br>     UVM_PACK, UVM_UNPACK: begin                                                \<br>       $cast(__local_packer__, __local_op__.get_policy());                      \<br>     end                                                                        \<br>     UVM_COPY: begin                                                            \<br>       if (local_rhs__ == null) return;                                         \<br>       $cast(__local_copier__, __local_op__.get_policy());                      \<br>     end                                                                        \<br>     UVM_SET: begin                                                             \<br>       if (local_rsrc__ == null) return;                                        \<br>     end                                                                        \<br>     UVM_CHECK_FIELDS: begin                                                    \<br>       $cast(__local_field_names__, __local_op__.get_rhs());                    \<br>     end                                                                        \<br>     default:                                                                   \<br>       return; /* unknown op, just return */                                    \<br>   endcase                                                                      \<br><br>// @uvm-ieee 1800.2-2020 manual B.2.1.1<br>`define uvm_field_utils_end \<br>endfunction : __m_uvm_execute_field_op</pre><p>This is some complicated-looking code, you don’t have to understand it as of now (we will discuss it later in depth), but essentially, when we write field macros, UVM internally keeps track of these fields and uses them for operations on the transaction objects, such as:</p><pre>copy()<br>compare()<br>print()<br>pack()<br>unpack()<br>record()</pre><p>That’s it for part 001. Sorry for including the actual library code, but it shows how much code is hidden, making our testbench easier to write without having to implement all the standard features and just focus on what is required for our design.</p><p>Thankyou.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=07380470e9b4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Quiet Cost of Rank-Driven Education]]></title>
            <link>https://medium.com/age-of-awareness/the-quiet-cost-of-rank-driven-education-6b0be12ca055?source=rss-5277201fa2c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b0be12ca055</guid>
            <category><![CDATA[knowledge]]></category>
            <category><![CDATA[education]]></category>
            <category><![CDATA[higher-education]]></category>
            <dc:creator><![CDATA[lulu2k2]]></dc:creator>
            <pubDate>Wed, 17 Dec 2025 20:27:20 GMT</pubDate>
            <atom:updated>2026-01-22T08:26:48.195Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gP99lTNKBRWihNg7LO_dMw.png" /></figure><p>Every year, millions of students across Asia prepare for increasingly difficult entrance examinations. The competition is intense, the syllabi are vast, and the margin for error is razor-thin. The stated goal is meritocracy: reward the hardest workers with seats at the best universities.</p><p>But there is a paradox hidden in this system that we rarely talk about.</p><p>No matter how difficult the exams become, top universities still have a fixed number of seats. Only a small fraction of students will receive top ranks. This means that even as students study more, practice more, and sacrifice more, the outcome distribution barely changes. The pressure increases, but opportunity does not.</p><p>What <em>does</em> change is how students learn.</p><h3>Learning to Win Exams vs Learning to Think</h3><p>Rank-driven systems naturally reward a specific kind of intelligence: speed, accuracy, pattern recognition, and obedience to the syllabus. These are valuable skills. They produce reliable engineers, doctors, and managers. But they also train students to optimize for <em>known answers</em>.</p><p>Over time, students internalize a subtle rule: don’t take intellectual risks. Don’t explore ideas that are not examinable. Don’t ask questions that don’t have a scoring rubric. When failure carries a heavy penalty, curiosity becomes expensive.</p><p>This is not because students lack creativity. It’s because the system does not incentivize its use.</p><h3>The Hidden Tradeoff</h3><p>Asian education systems are remarkably good at operating at scale. When millions compete for limited resources, standardized exams are efficient, objective, and politically defensible. They minimize ambiguity and perceived unfairness.</p><p>But innovation thrives on the opposite conditions: variance, uncertainty, and tolerance for failure.</p><p>When a system is optimized to reduce variance, it will also reduce the probability of outliers. Unfortunately, most breakthroughs come from outliers.</p><h3>Why Ownership Often Emerges Elsewhere</h3><p>It is not an accident that many globally influential companies are founded in ecosystems where education is less rigid and failure is more socially acceptable. These environments allow people to try, fail, pivot, and try again without being permanently labeled by a single outcome.</p><p>In contrast, many highly skilled graduates from Asia end up working within structures designed elsewhere. They build, optimize, and execute brilliantly but rarely control the direction. This is not a talent gap. It is a systems gap.</p><h3>This Is Not About the “West vs Asia”</h3><p>The issue is not geography, culture, or intelligence. It is an incentive design.</p><p>Asian systems optimize for fairness and reliability. Western elite systems often tolerate inequality and inefficiency in exchange for higher upside. Each approach has strengths and weaknesses. The problem arises when a society expects innovation from a system that is explicitly designed to avoid risk.</p><h3>What Needs to Change</h3><p>Raising exam difficulty will not solve this. Reducing creativity to a grading rubric will not work either. Meaningful change requires:</p><ul><li>Multiple pathways to success, not a single rank</li><li>Space for open-ended projects with no “model answer.”</li><li>Social acceptance that failure is part of learning, not a permanent verdict</li><li>Evaluation that values reasoning and originality, not just correctness</li></ul><p>These are difficult reforms because they introduce uncertainty, and uncertainty is uncomfortable.</p><h3>A Personal Reflection</h3><p>For individuals growing up in rank-driven systems, the goal should not be to reject the system entirely, but to recognize its limits. Use it to build strong fundamentals. Then, consciously step outside it. Ask questions that are not rewarded. Build things that won’t be graded. Learn to be wrong in your own space before trying to be right in public.</p><p>Systems shape outcomes, but they don’t fully determine them.</p><p><em>This discussion critiques education systems and incentive structures, not students, cultures, or regions. This essay was inspired by a YouTube video that prompted me to reflect on how rank-based education systems influence learning behavior on a large scale.</em></p><p><a href="https://youtu.be/g7PWrn9EpN8?si=bqU1_ouCEDakuX3t">https://youtu.be/g7PWrn9EpN8?si=bqU1_ouCEDakuX3t</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b0be12ca055" width="1" height="1" alt=""><hr><p><a href="https://medium.com/age-of-awareness/the-quiet-cost-of-rank-driven-education-6b0be12ca055">The Quiet Cost of Rank-Driven Education</a> was originally published in <a href="https://medium.com/age-of-awareness">Age of Awareness</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>