For decades, degrees from elite institutions served as a primary proxy for competence. Employers, lacking the time and resources to assess every candidate in depth, relied on a bachelor’s degree—especially from prestigious universities—as a reliable filter. A degree wasn’t just proof of education; it signaled intelligence, discipline, and most importantly, adaptability.

However, the hiring landscape has undergone a profound shift in recent years. Instead of reducing reliance on credentials, the rise of digital platforms—social media, LinkedIn, and open-access knowledge—has raised the bar for job seekers. Employers now have unprecedented visibility into candidates’ work, skills, and achievements. In theory, this should have made hiring more meritocratic. In reality, it has inflated expectations to unattainable levels.

The New Hiring Paradox

What used to be a simple requirement—a degree from a good school—has now evolved into a demand for hyper-specialization. Increasingly, bachelor’s and even general master’s degrees are no longer enough to secure jobs in technical fields. Instead, many roles now require PhDs or years of niche expertise just to enter the field.

This phenomenon is fueled by several factors:

1. Global Competition

The internet has expanded the hiring pool to a global scale. Employers can now access highly specialized talent from anywhere in the world, allowing them to be far more selective. What was once an exclusive skill set in one region is now commonplace in another.

2. Credential Inflation

As more people obtain degrees, their value as a differentiator diminishes. Companies have responded by raising their minimum requirements. Where a bachelor’s once sufficed, a master’s is now expected. Where a master’s was impressive, a PhD is now preferred.

3. Short-Term Optimization

Employers increasingly prioritize immediate productivity over long-term potential. Instead of hiring adaptable employees and training them on the job, they seek “plug-and-play” specialists who already possess highly specific skills. This mindset discourages generalist problem-solvers and rewards niche technical mastery.

4. Investor-Driven Instability

Many companies, particularly in tech and finance, are under constant pressure from investors to optimize short-term efficiency. This has led to a hiring culture that values immediate returns over developmental growth, reinforcing the demand for pre-trained specialists.

The Death of Learning on the Job

A troubling consequence of this shift is the erosion of traditional career development pathways. Entry-level roles increasingly demand years of experience and niche expertise that were once developed on the job.

For example:

• Journalists are expected to have extensive portfolios before even being considered for junior positions.
• Administrative roles that once required only organizational skills now demand software proficiency, data analytics experience, and specialized certifications.
• Engineering and data science jobs frequently list PhDs as a requirement, even for tasks that don’t inherently demand doctoral-level expertise.

This shift has created a paradox: despite knowledge being more accessible than ever, breaking into technical industries is harder than ever.

The Consequences: A Workforce in Perpetual Specialization

Graduates today find themselves caught in a loop of endless upskilling. Rather than focusing on meaningful contributions, many are forced into relentless self-positioning—constantly chasing the next credential, certification, or specialization just to remain employable.

This dynamic is unsustainable. It prioritizes immediate efficiency over long-term resilience, leading to:

• Increased anxiety and job market uncertainty for young professionals.
• A lack of investment in employee development, reducing overall workforce adaptability.
• A fragile labor market, where companies hire for short-term needs but struggle with long-term retention and innovation.

Breaking the Cycle

If this trend continues, we risk creating a system where the cost of proving competence outweighs the reward of employment itself. To build a more sustainable job market, companies must rethink credential inflation, as requiring excessive degrees for jobs that don’t genuinely need them creates artificial barriers to entry.

Ultimately, the future of work must prioritize growth over gatekeeping. If businesses fail to adapt, they may find themselves caught in the same cycle of instability they have imposed on workers—constantly hiring, constantly replacing, but never truly building.

TL;DR, The job market has shifted from valuing human competence (learning and adaptability) to robotic competence (immediate efficiency). Companies, pressured by short-term profitability and investor demands, now prioritize job-ready specialists over long-term employee development.

Corporate instability has eroded job security, with mass layoffs affecting even highly profitable firms. Education’s role in hiring is declining—degrees no longer guarantee jobs, yet elite credentials still act as soft filters.

Social media and global hiring have made recruitment hyper-competitive, leading to paradoxical expectations—requiring extensive experience for entry-level roles while offering little stability or career growth. Hiring has become more about filtering out candidates than fostering mutual investment, leaving workers in a cycle of uncertainty and constant upskilling.

The Shift from Human to Robotic Competence in Hiring

I define competence in two ways:

Human competence is the ability to learn and improve over time. It’s not just about performing a task but mastering it through experience. Some learn faster than others, creating a natural hierarchy—those who quickly refine their skills rise to the top, while others take longer to reach the same level. Robotic competence is the ability to perform a task efficiently from the start, prioritizing immediate execution over learning. It creates a hierarchy where those with existing expertise rise to the top, while those needing development are undervalued.

For decades, hiring seemed to be based on human competence—the ability to grow within a role. Employers seemed to value intelligence, adaptability, and problem-solving ability, even if candidates needed time to ramp up. However, in today’s job market, the emphasis has shifted to robotic competence, where employees are expected to be immediately productive from day one.

Corporate Instability and the Decline of Long-Term Employment

This shift is primarily driven by corporate instability, as companies face mounting pressure from competitive credit markets and the growing emphasis on short-term performance metrics. With the increasing uncertainty of long-term viability, many businesses rely on loans, venture capital, or credit lines to stay afloat, compelling them to pursue immediate profitability to satisfy investors and lenders. Failure to meet these expectations often results in reduced funding, prompting cost-cutting measures, layoffs, or even closures.

While corporate giants are not facing the same existential challenges as smaller companies, they remain subject to similar pressures, such as investor expectations and market volatility. These firms prioritize short-term productivity by leveraging global hiring trends and focusing on specialized expertise to ensure immediate returns. At the same time, they assess candidates’ ability to withstand the demanding, high-pressure work culture. Despite this, they continue to invest in long-term talent development through robust training programs for new recruits. However, the risk remains largely with the employee—job security is uncertain, and layoffs can occur at any time, even for high performers. (Hence, “laid-back” jobs are now seen as rare, referring to the more stable 9-5 positions that once existed.)

As a result, businesses are increasingly reluctant to invest in long-term employee development, opting instead to hire fully trained specialists while offering limited job security, pensions, or career advancement opportunities. By prioritizing immediate efficiency over organizational stability, companies shift the risks onto employees—engaging them on contract-based terms, maintaining stagnant wages, and eliminating traditional pathways for career growth. This dynamic fosters a labor market that values short-term productivity over long-term skill development, perpetuating an unsustainable cycle of uncertainty for workers.

Mass layoffs are no longer exclusive to struggling companies; even highly profitable corporations are cutting jobs in pursuit of short-term efficiency. According to Statista, as of January 2024, Amazon had announced over 27,000 layoffs across five separate rounds, while Meta and Google reported approximately 21,000 and 12,000 job cuts, respectively. These reductions are often driven by shifting investor priorities rather than financial necessity, illustrating how corporate instability now extends beyond failing businesses to even the most successful firms.

Startups, particularly those reliant on venture capital funding, also contribute to this instability. Aggressive hiring during periods of financial influx is often followed by mass layoffs when funding dries up. Companies like WeWork exemplify this boom-and-bust cycle, where rapid expansion is fueled by external investment rather than sustainable business models. This leads to unpredictable hiring patterns, where employees face abrupt terminations as soon as investor sentiment shifts.

The gig economy further reinforces this instability. Companies such as Uber and DoorDash rely heavily on independent contractors, minimizing commitments to employee benefits, job security, and career development. While this model provides operational flexibility for businesses, it leaves workers in a precarious position—trapped in temporary roles with few opportunities for long-term growth or financial stability.

Since firms are empowered to hire individuals who meet immediate needs, they have little incentive to invest in employees they intend to retain for the long haul. This creates a vicious feedback loop, with companies increasingly focused on robotic competence, to the detriment of long-term development and employee well-being.

The Decline of Degrees: Education’s Waning Value in the Job Market

There has also been a huge erosion of faith in formal education as a pathway to employment. Traditional degrees once served as a proxy for human competence, signaling a person’s ability to learn and adapt over time. But as companies demand job-ready candidates with highly specific skills and focus on immediate productivity, degrees alone have become insufficient. Graduates now find themselves constantly chasing certifications and training programs just to keep up with ever-evolving job descriptions, further deepening their anxiety and uncertainty about the future. Meanwhile the cultural weight of academic pedigree still persists, creating a soft eligibility filter, where attending a top school is less about proving robotic competence and more about leveraging human competence as social capital just to open doors.

However, this elevation in status matters less as job security erodes. Over the past two to three decades, the risk of redundancy has been rising. As the job market shifts further toward a gig economy model, human competence is losing relevance, replaced by a system that prioritizes immediate utility over long-term potential, undermining traditional seniority hierarchies. These hierarchies once made sense when companies valued long-term learning and growth, even if they were never perfect representations of human competence.

The traditional belief that a college degree guarantees job security is fading. While tech giants like Tesla and Google have publicly stated that degrees are not required for employment, hiring patterns tell a different story. In reality, these companies continue to prioritize candidates from elite institutions, reinforcing existing hierarchies while maintaining the illusion of accessibility. This contradiction reveals the shifting role of degrees—not as a definitive requirement, but as a soft eligibility filter that still holds significant weight in high-profile hiring decisions.

Beyond tech, inflated job qualifications are becoming the norm across industries. Entry-level positions now demand years of experience and specialized skills that were once learned on the job. In journalism, for example, aspiring writers are often expected to have multiple internships and portfolios rivaling those of mid-career professionals. Even administrative assistant roles frequently require a bachelor’s degree, proficiency in specialized software, and extensive industry knowledge, making it increasingly difficult for new graduates to break into the workforce.

The Competence Paradox: Learning vs. Immediate Specialization

The problem isn’t just the system’s expectations—it’s that they fundamentally conflict. These expectations clash with the conditions humans need to work efficiently—such as purpose and stability—while also contradicting each other. Professionally, we’re expected to be robotically competent, yet culturally, we’re still judged by college degrees that signal human competence. The implicit belief is that robotic competence secures a job, but human competence allows you to keep it. However, if you’re too humanly competent but lack robotic competence, employers may see you as a short-term investment—someone who will quickly outgrow the role and move on. Conversely, someone with robotic competence but less human adaptability may be seen as a more stable, long-term hire.

This creates a paradox: those who excel in human competence often struggle with robotic competence early in their careers. Ideally, human competence is about learning how to learn—developing as a generalist who can adapt to new challenges. Since the brain continues developing until age 25, early education should focus on broad learning abilities. In contrast, prioritizing robotic competence means mastering a single skill to the point of specialization. While this makes candidates immediately employable, it often comes at the cost of not developing the ability to learn and pivot over time.

The Cost of Early Specialization and Workplace Instability

As a result, young people are forced into a relentless game of strategic self-positioning, orienting their skills according to market forces rather than genuine interests or strengths. Instead of contributing to society in meaningful ways, they are preoccupied with “getting ahead,” despite a lack of clear structures that facilitate stable, symbiotic employer-employee relationships. This instability, combined with the expectation to specialize too early—before their cognitive development is complete—leaves many feeling confused and disillusioned about the job market.

This isn’t just bad for individuals—it’s detrimental to companies as well. Imagine if businesses prioritized building positive relationships with employees rather than treating them as disposable assets. What if workers stayed not just because of profit margins but because they genuinely enjoyed working with their employers? A system built on mutual investment and dedication would benefit both sides far more than the current cycle of instability and short-term efficiency.

The Hidden Cost of Office Politics in the Hiring Process and Beyond

Then there’s the issue of office politics—many employees struggle with toxic workplace dynamics, but instead of getting proper support, they’re forced to either endure dysfunctional relationships with colleagues and bosses or actively engage in office politics to stay afloat. Some do it just to survive, while others exploit it to climb the corporate ladder. This highlights a deeper issue: corporate hierarchies are another form of robotic competence hierarchies. If you excel at office politics, you advance. If you don’t, you risk stagnation or getting pushed out entirely. This brings us back to the point about recruiters constantly checking for conformity to office political culture under the guise of “stress-testing” during interviews.

Toxic work environments aren’t just a byproduct of individual personalities—they’re often deeply ingrained in company culture. In July 2021, Activision Blizzard faced a lawsuit alleging a pervasive “frat boy” culture, where female employees experienced systemic harassment and discrimination. TIME reported that the company’s dismissive response led to employee walkouts, underscoring how corporate culture can be weaponized against workers rather than supporting their growth.

Similarly, reports on Amazon’s warehouse conditions have shed light on extreme performance pressures and high turnover rates. Employees are expected to meet grueling efficiency metrics, often at the expense of their physical and mental well-being. These workplace dynamics reveal a troubling pattern: rather than fostering long-term development, many companies prioritize maintaining rigid hierarchies that reward endurance over meaningful contribution

Maybe it’s time to acknowledge that the workplace sociopolitical environment itself needs serious psychological evaluation—rather than placing all the scrutiny on a new hire who knows nothing about office politics. Companies expect employees to “perform under pressure” without ever questioning whether that pressure is necessary, or if their selection bias simply favors those who can endure it, keeping the cycle going regardless of its actual value.

How Social Media Transformed Hiring into a One-Sided Market

The proliferation of social media and professional networking platforms like LinkedIn has had a big part to play in dramatically reshaping this hiring landscape. What was once a job opening visible to 100 people in a town of 2,000 is now accessible to hundreds of thousands across the country, regardless of location.

With the expectation that top-tier talent will inevitably apply—whether through referrals, job-sharing, or sheer necessity—companies are less inclined to compromise. The hiring process has become increasingly asymmetrical, with decision-making power concentrated in the hands of employers, creating a one-sided market. Rather than investing in workforce development, businesses now demand unrealistic combinations of expertise, leading to paradoxical expectations, such as requiring “5+ years of experience” for entry-level positions.

Meanwhile, social media has also exacerbated the anxiety surrounding the job search. Platforms like LinkedIn, Instagram, and TikTok have become spaces where professionals share their struggles—viral posts frequently highlight experiences of submitting hundreds of applications without a single response. Some job seekers admit to embellishing their résumés or tailoring their online personas to match corporate expectations, illustrating the growing desperation in an increasingly competitive market.

The Hiring Catch-22: Rising Standards, Declining Security

In response to financial insecurity, job seekers are applying en masse to various positions, often without regard for their qualifications, believing that the volume of applications improves their chances of securing employment. This influx of applications has led employers to develop an inflated sense of selectivity, prompting them to raise job requirements and seek highly specialized candidates without offering commensurate compensation. This specialization does little to improve candidates’ chances of better pay, as companies prioritize efficiency driven by market forces.

This creates a vicious feedback loop: as companies set unrealistic expectations, job seekers panic and engage in unstructured upskilling, taking on certifications and courses to stay competitive. However, this only reinforces employers’ belief that highly skilled workers are abundant and easily replaceable. As hiring standards continue to rise, workers are left feeling permanently unqualified, while businesses paradoxically struggle to find the “perfect” hire.

From Hiring to Filtering: The Rise of the Rejection-First Job Market and the Decline of Mutual Growth

Rather than serving as the start of a mutually beneficial relationship, the hiring process has increasingly become a rejection filter. Companies now focus on eliminating “risky” candidates and selecting the most “ideal” worker—someone who delivers immediate short-term value rather than fostering long-term growth and collaboration. This mindset discourages investment in employee development, erodes workplace stability, and fuels a culture of disengagement, where workers feel disposable rather than valued contributors to society.

Lightbox2

PhotoSwipe

Spotlight JS

Venobox

First tabs

To add tabs, use the following syntax:

{% tabs group-name %}

{% tab group-name tab-name-1 %}

Content 1

{% endtab %}

{% tab group-name tab-name-2 %}

Content 2

{% endtab %}

{% endtabs %}

With this you can generate visualizations like:

• php
• js
• ruby

• var_dump('hello');
  

• console.log("hello");
  

• pputs 'hello'
  

Another example

• yaml
• json

• hello:
    - "whatsup"
    - "hi"
  

• {
    "hello": ["whatsup", "hi"]
  }
  

Tabs for something else

• text
• quote
• list

• Regular text

• A quote

• Hipster list

  • brunch
  • fixie
  • raybans
  • messenger bag

```typograms
+----+
|    |---> My first diagram!
+----+
```

Which generates:

+----+
|    |---> My first diagram!
+----+

Another example:

```typograms
.------------------------.
|.----------------------.|
||"https://example.com" ||
|'----------------------'|
| ______________________ |
||                      ||
||   Welcome!           ||
||                      ||
||                      ||
||  .----------------.  ||
||  | username       |  ||
||  '----------------'  ||
||  .----------------.  ||
||  |"*******"       |  ||
||  '----------------'  ||
||                      ||
||  .----------------.  ||
||  |   "Sign-up"    |  ||
||  '----------------'  ||
||                      ||
|+----------------------+|
.------------------------.
```

which generates:

.------------------------.
|.----------------------.|
||"https://example.com" ||
|'----------------------'|
| ______________________ |
||                      ||
||   Welcome!           ||
||                      ||
||                      ||
||  .----------------.  ||
||  | username       |  ||
||  '----------------'  ||
||  .----------------.  ||
||  |"*******"       |  ||
||  '----------------'  ||
||                      ||
||  .----------------.  ||
||  |   "Sign-up"    |  ||
||  '----------------'  ||
||                      ||
|+----------------------+|
.------------------------.

For more examples, check out the typograms documentation.

```pseudocode
% This quicksort algorithm is extracted from Chapter 7, Introduction to Algorithms (3rd edition)
\begin{algorithm}
\caption{Quicksort}
\begin{algorithmic}
\PROCEDURE{Quicksort}{$$A, p, r$$}
    \IF{$$p < r$$}
        \STATE $$q = $$ \CALL{Partition}{$$A, p, r$$}
        \STATE \CALL{Quicksort}{$$A, p, q - 1$$}
        \STATE \CALL{Quicksort}{$$A, q + 1, r$$}
    \ENDIF
\ENDPROCEDURE
\PROCEDURE{Partition}{$$A, p, r$$}
    \STATE $$x = A[r]$$
    \STATE $$i = p - 1$$
    \FOR{$$j = p$$ \TO $$r - 1$$}
        \IF{$$A[j] < x$$}
            \STATE $$i = i + 1$$
            \STATE exchange
            $$A[i]$$ with $$A[j]$$
        \ENDIF
        \STATE exchange $$A[i]$$ with $$A[r]$$
    \ENDFOR
\ENDPROCEDURE
\end{algorithmic}
\end{algorithm}
```

Generates:

% This quicksort algorithm is extracted from Chapter 7, Introduction to Algorithms (3rd edition)
\begin{algorithm}
\caption{Quicksort}
\begin{algorithmic}
\PROCEDURE{Quicksort}{$$A, p, r$$}
    \IF{$$p < r$$}
        \STATE $$q = $$ \CALL{Partition}{$$A, p, r$$}
        \STATE \CALL{Quicksort}{$$A, p, q - 1$$}
        \STATE \CALL{Quicksort}{$$A, q + 1, r$$}
    \ENDIF
\ENDPROCEDURE
\PROCEDURE{Partition}{$$A, p, r$$}
    \STATE $$x = A[r]$$
    \STATE $$i = p - 1$$
    \FOR{$$j = p$$ \TO $$r - 1$$}
        \IF{$$A[j] < x$$}
            \STATE $$i = i + 1$$
            \STATE exchange
            $$A[i]$$ with $$A[j]$$
        \ENDIF
        \STATE exchange $$A[i]$$ with $$A[r]$$
    \ENDFOR
\ENDPROCEDURE
\end{algorithmic}
\end{algorithm}

```diff
diff --git a/sample.js b/sample.js
index 0000001..0ddf2ba
--- a/sample.js
+++ b/sample.js
@@ -1 +1 @@
-console.log("Hello World!")
+console.log("Hello from Diff2Html!")
```

Which generates:

diff --git a/sample.js b/sample.js
index 0000001..0ddf2ba
--- a/sample.js
+++ b/sample.js
@@ -1 +1 @@
-console.log("Hello World!")
+console.log("Hello from Diff2Html!")

But this is difficult to read, specially if you have a large diff. You can use diff2html to display a more readable version of the diff. For this, just use diff2html instead of diff for the code block language:

```diff2html
diff --git a/sample.js b/sample.js
index 0000001..0ddf2ba
--- a/sample.js
+++ b/sample.js
@@ -1 +1 @@
-console.log("Hello World!")
+console.log("Hello from Diff2Html!")
```

If we use a longer example, for example this commit from diff2html, it will generate the following output:

From 2aaae31cc2a37bfff83430c2c914b140bee59b6a Mon Sep 17 00:00:00 2001
From: Rodrigo Fernandes <rtfrodrigo@gmail.com>
Date: Sun, 9 Oct 2016 16:41:54 +0100
Subject: [PATCH 1/2] Initial template override support

---
 scripts/hulk.js                    |  4 ++--
 src/diff2html.js                   |  3 +--
 src/file-list-printer.js           | 11 ++++++++---
 src/hoganjs-utils.js               | 29 +++++++++++++++++------------
 src/html-printer.js                |  6 ++++++
 src/line-by-line-printer.js        |  6 +++++-
 src/side-by-side-printer.js        |  6 +++++-
 test/file-list-printer-tests.js    |  2 +-
 test/hogan-cache-tests.js          | 18 +++++++++++++++---
 test/line-by-line-tests.js         |  3 +--
 test/side-by-side-printer-tests.js |  3 +--
 11 files changed, 62 insertions(+), 29 deletions(-)

diff --git a/scripts/hulk.js b/scripts/hulk.js
index 5a793c18..a4b1a4d5 100755
--- a/scripts/hulk.js
+++ b/scripts/hulk.js
@@ -173,11 +173,11 @@ function namespace(name) {
 // write a template foreach file that matches template extension
 templates = extractFiles(options.argv.remain)
   .map(function(file) {
-    var openedFile = fs.readFileSync(file, 'utf-8');
+    var openedFile = fs.readFileSync(file, 'utf-8').trim();
     var name;
     if (!openedFile) return;
     name = namespace(path.basename(file).replace(/\..*$/, ''));
-    openedFile = removeByteOrderMark(openedFile.trim());
+    openedFile = removeByteOrderMark(openedFile);
     openedFile = wrap(file, name, openedFile);
     if (!options.outputdir) return openedFile;
     fs.writeFileSync(path.join(options.outputdir, name + '.js')
diff --git a/src/diff2html.js b/src/diff2html.js
index 21b0119e..64e138f5 100644
--- a/src/diff2html.js
+++ b/src/diff2html.js
@@ -7,7 +7,6 @@

 (function() {
   var diffParser = require('./diff-parser.js').DiffParser;
-  var fileLister = require('./file-list-printer.js').FileListPrinter;
   var htmlPrinter = require('./html-printer.js').HtmlPrinter;

   function Diff2Html() {
@@ -43,7 +42,7 @@

     var fileList = '';
     if (configOrEmpty.showFiles === true) {
-      fileList = fileLister.generateFileList(diffJson, configOrEmpty);
+      fileList = htmlPrinter.generateFileListSummary(diffJson, configOrEmpty);
     }

     var diffOutput = '';
diff --git a/src/file-list-printer.js b/src/file-list-printer.js
index e408d9b2..1e0a2c61 100644
--- a/src/file-list-printer.js
+++ b/src/file-list-printer.js
@@ -8,11 +8,16 @@
 (function() {
   var printerUtils = require('./printer-utils.js').PrinterUtils;

-  var hoganUtils = require('./hoganjs-utils.js').HoganJsUtils;
+  var hoganUtils;
+
   var baseTemplatesPath = 'file-summary';
   var iconsBaseTemplatesPath = 'icon';

-  function FileListPrinter() {
+  function FileListPrinter(config) {
+    this.config = config;
+
+    var HoganJsUtils = require('./hoganjs-utils.js').HoganJsUtils;
+    hoganUtils = new HoganJsUtils(config);
   }

   FileListPrinter.prototype.generateFileList = function(diffFiles) {
@@ -38,5 +43,5 @@
     });
   };

-  module.exports.FileListPrinter = new FileListPrinter();
+  module.exports.FileListPrinter = FileListPrinter;
 })();
diff --git a/src/hoganjs-utils.js b/src/hoganjs-utils.js
index 9949e5fa..0dda08d7 100644
--- a/src/hoganjs-utils.js
+++ b/src/hoganjs-utils.js
@@ -8,18 +8,19 @@
 (function() {
   var fs = require('fs');
   var path = require('path');
-
   var hogan = require('hogan.js');

   var hoganTemplates = require('./templates/diff2html-templates.js');

-  var templatesPath = path.resolve(__dirname, 'templates');
+  var extraTemplates;

-  function HoganJsUtils() {
+  function HoganJsUtils(configuration) {
+    this.config = configuration || {};
+    extraTemplates = this.config.templates || {};
   }

-  HoganJsUtils.prototype.render = function(namespace, view, params, configuration) {
-    var template = this.template(namespace, view, configuration);
+  HoganJsUtils.prototype.render = function(namespace, view, params) {
+    var template = this.template(namespace, view);
     if (template) {
       return template.render(params);
     }
@@ -27,17 +28,16 @@
     return null;
   };

-  HoganJsUtils.prototype.template = function(namespace, view, configuration) {
-    var config = configuration || {};
+  HoganJsUtils.prototype.template = function(namespace, view) {
     var templateKey = this._templateKey(namespace, view);

-    return this._getTemplate(templateKey, config);
+    return this._getTemplate(templateKey);
   };

-  HoganJsUtils.prototype._getTemplate = function(templateKey, config) {
+  HoganJsUtils.prototype._getTemplate = function(templateKey) {
     var template;

-    if (!config.noCache) {
+    if (!this.config.noCache) {
       template = this._readFromCache(templateKey);
     }

@@ -53,6 +53,7 @@

     try {
       if (fs.readFileSync) {
+        var templatesPath = path.resolve(__dirname, 'templates');
         var templatePath = path.join(templatesPath, templateKey);
         var templateContent = fs.readFileSync(templatePath + '.mustache', 'utf8');
         template = hogan.compile(templateContent);
@@ -66,12 +67,16 @@
   };

   HoganJsUtils.prototype._readFromCache = function(templateKey) {
-    return hoganTemplates[templateKey];
+    return extraTemplates[templateKey] || hoganTemplates[templateKey];
   };

   HoganJsUtils.prototype._templateKey = function(namespace, view) {
     return namespace + '-' + view;
   };

-  module.exports.HoganJsUtils = new HoganJsUtils();
+  HoganJsUtils.prototype.compile = function(templateStr) {
+    return hogan.compile(templateStr);
+  };
+
+  module.exports.HoganJsUtils = HoganJsUtils;
 })();
diff --git a/src/html-printer.js b/src/html-printer.js
index 585d5b66..13f83047 100644
--- a/src/html-printer.js
+++ b/src/html-printer.js
@@ -8,6 +8,7 @@
 (function() {
   var LineByLinePrinter = require('./line-by-line-printer.js').LineByLinePrinter;
   var SideBySidePrinter = require('./side-by-side-printer.js').SideBySidePrinter;
+  var FileListPrinter = require('./file-list-printer.js').FileListPrinter;

   function HtmlPrinter() {
   }
@@ -22,5 +23,10 @@
     return sideBySidePrinter.generateSideBySideJsonHtml(diffFiles);
   };

+  HtmlPrinter.prototype.generateFileListSummary = function(diffJson, config) {
+    var fileListPrinter = new FileListPrinter(config);
+    return fileListPrinter.generateFileList(diffJson);
+  };
+
   module.exports.HtmlPrinter = new HtmlPrinter();
 })();
diff --git a/src/line-by-line-printer.js b/src/line-by-line-printer.js
index b07eb53c..d230bedd 100644
--- a/src/line-by-line-printer.js
+++ b/src/line-by-line-printer.js
@@ -11,7 +11,8 @@
   var utils = require('./utils.js').Utils;
   var Rematch = require('./rematch.js').Rematch;

-  var hoganUtils = require('./hoganjs-utils.js').HoganJsUtils;
+  var hoganUtils;
+
   var genericTemplatesPath = 'generic';
   var baseTemplatesPath = 'line-by-line';
   var iconsBaseTemplatesPath = 'icon';
@@ -19,6 +20,9 @@

   function LineByLinePrinter(config) {
     this.config = config;
+
+    var HoganJsUtils = require('./hoganjs-utils.js').HoganJsUtils;
+    hoganUtils = new HoganJsUtils(config);
   }

   LineByLinePrinter.prototype.makeFileDiffHtml = function(file, diffs) {
diff --git a/src/side-by-side-printer.js b/src/side-by-side-printer.js
index bbf1dc8d..5e3033b3 100644
--- a/src/side-by-side-printer.js
+++ b/src/side-by-side-printer.js
@@ -11,7 +11,8 @@
   var utils = require('./utils.js').Utils;
   var Rematch = require('./rematch.js').Rematch;

-  var hoganUtils = require('./hoganjs-utils.js').HoganJsUtils;
+  var hoganUtils;
+
   var genericTemplatesPath = 'generic';
   var baseTemplatesPath = 'side-by-side';
   var iconsBaseTemplatesPath = 'icon';
@@ -26,6 +27,9 @@

   function SideBySidePrinter(config) {
     this.config = config;
+
+    var HoganJsUtils = require('./hoganjs-utils.js').HoganJsUtils;
+    hoganUtils = new HoganJsUtils(config);
   }

   SideBySidePrinter.prototype.makeDiffHtml = function(file, diffs) {
diff --git a/test/file-list-printer-tests.js b/test/file-list-printer-tests.js
index a502a46f..60ea3208 100644
--- a/test/file-list-printer-tests.js
+++ b/test/file-list-printer-tests.js
@@ -1,6 +1,6 @@
 var assert = require('assert');

-var fileListPrinter = require('../src/file-list-printer.js').FileListPrinter;
+var fileListPrinter = new (require('../src/file-list-printer.js').FileListPrinter)();

 describe('FileListPrinter', function() {
   describe('generateFileList', function() {
diff --git a/test/hogan-cache-tests.js b/test/hogan-cache-tests.js
index 190bf6f8..3bb754ac 100644
--- a/test/hogan-cache-tests.js
+++ b/test/hogan-cache-tests.js
@@ -1,6 +1,6 @@
 var assert = require('assert');

-var HoganJsUtils = require('../src/hoganjs-utils.js').HoganJsUtils;
+var HoganJsUtils = new (require('../src/hoganjs-utils.js').HoganJsUtils)();
 var diffParser = require('../src/diff-parser.js').DiffParser;

 describe('HoganJsUtils', function() {
@@ -21,16 +21,28 @@ describe('HoganJsUtils', function() {
       });
       assert.equal(emptyDiffHtml, result);
     });
+
     it('should render view without cache', function() {
       var result = HoganJsUtils.render('generic', 'empty-diff', {
         contentClass: 'd2h-code-line',
         diffParser: diffParser
       }, {noCache: true});
-      assert.equal(emptyDiffHtml + '\n', result);
+      assert.equal(emptyDiffHtml, result);
     });
+
     it('should return null if template is missing', function() {
-      var result = HoganJsUtils.render('generic', 'missing-template', {}, {noCache: true});
+      var hoganUtils = new (require('../src/hoganjs-utils.js').HoganJsUtils)({noCache: true});
+      var result = hoganUtils.render('generic', 'missing-template', {});
       assert.equal(null, result);
     });
+
+    it('should allow templates to be overridden', function() {
+      var emptyDiffTemplate = HoganJsUtils.compile('<p></p>');
+
+      var config = {templates: {'generic-empty-diff': emptyDiffTemplate}};
+      var hoganUtils = new (require('../src/hoganjs-utils.js').HoganJsUtils)(config);
+      var result = hoganUtils.render('generic', 'empty-diff', {myName: 'Rodrigo Fernandes'});
+      assert.equal('<p>Rodrigo Fernandes</p>', result);
+    });
   });
 });
diff --git a/test/line-by-line-tests.js b/test/line-by-line-tests.js
index 1cd92073..8869b3df 100644
--- a/test/line-by-line-tests.js
+++ b/test/line-by-line-tests.js
@@ -14,7 +14,7 @@ describe('LineByLinePrinter', function() {
         '            File without changes\n' +
         '        </div>\n' +
         '    </td>\n' +
-        '</tr>\n';
+        '</tr>';

       assert.equal(expected, fileHtml);
     });
@@ -422,7 +422,6 @@ describe('LineByLinePrinter', function() {
         '        </div>\n' +
         '    </td>\n' +
         '</tr>\n' +
-        '\n' +
         '                </tbody>\n' +
         '            </table>\n' +
         '        </div>\n' +
diff --git a/test/side-by-side-printer-tests.js b/test/side-by-side-printer-tests.js
index 76625f8e..771daaa5 100644
--- a/test/side-by-side-printer-tests.js
+++ b/test/side-by-side-printer-tests.js
@@ -14,7 +14,7 @@ describe('SideBySidePrinter', function() {
         '            File without changes\n' +
         '        </div>\n' +
         '    </td>\n' +
-        '</tr>\n';
+        '</tr>';

       assert.equal(expectedRight, fileHtml.right);
       assert.equal(expectedLeft, fileHtml.left);
@@ -324,7 +324,6 @@ describe('SideBySidePrinter', function() {
         '        </div>\n' +
         '    </td>\n' +
         '</tr>\n' +
-        '\n' +
         '                    </tbody>\n' +
         '                </table>\n' +
         '            </div>\n' +

From f3cadb96677d0eb82fc2752dc3ffbf35ca9b5bdb Mon Sep 17 00:00:00 2001
From: Rodrigo Fernandes <rtfrodrigo@gmail.com>
Date: Sat, 15 Oct 2016 13:21:22 +0100
Subject: [PATCH 2/2] Allow uncompiled templates

---
 README.md                 |  3 +++
 src/hoganjs-utils.js      |  7 +++++++
 test/hogan-cache-tests.js | 24 +++++++++++++++++++++++-
 3 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 132c8a28..46909f25 100644
--- a/README.md
+++ b/README.md
@@ -98,6 +98,9 @@ The HTML output accepts a Javascript object with configuration. Possible options
   - `synchronisedScroll`: scroll both panes in side-by-side mode: `true` or `false`, default is `false`
   - `matchWordsThreshold`: similarity threshold for word matching, default is 0.25
   - `matchingMaxComparisons`: perform at most this much comparisons for line matching a block of changes, default is `2500`
+  - `templates`: object with previously compiled templates to replace parts of the html
+  - `rawTemplates`: object with raw not compiled templates to replace parts of the html
+  > For more information regarding the possible templates look into [src/templates](https://github.com/rtfpessoa/diff2html/tree/master/src/templates)

 ## Diff2HtmlUI Helper

diff --git a/src/hoganjs-utils.js b/src/hoganjs-utils.js
index 0dda08d7..b2e9c275 100644
--- a/src/hoganjs-utils.js
+++ b/src/hoganjs-utils.js
@@ -17,6 +17,13 @@
   function HoganJsUtils(configuration) {
     this.config = configuration || {};
     extraTemplates = this.config.templates || {};
+
+    var rawTemplates = this.config.rawTemplates || {};
+    for (var templateName in rawTemplates) {
+      if (rawTemplates.hasOwnProperty(templateName)) {
+        if (!extraTemplates[templateName]) extraTemplates[templateName] = this.compile(rawTemplates[templateName]);
+      }
+    }
   }

   HoganJsUtils.prototype.render = function(namespace, view, params) {
diff --git a/test/hogan-cache-tests.js b/test/hogan-cache-tests.js
index 3bb754ac..a34839c0 100644
--- a/test/hogan-cache-tests.js
+++ b/test/hogan-cache-tests.js
@@ -36,7 +36,7 @@ describe('HoganJsUtils', function() {
       assert.equal(null, result);
     });

-    it('should allow templates to be overridden', function() {
+    it('should allow templates to be overridden with compiled templates', function() {
       var emptyDiffTemplate = HoganJsUtils.compile('<p></p>');

       var config = {templates: {'generic-empty-diff': emptyDiffTemplate}};
@@ -44,5 +44,27 @@ describe('HoganJsUtils', function() {
       var result = hoganUtils.render('generic', 'empty-diff', {myName: 'Rodrigo Fernandes'});
       assert.equal('<p>Rodrigo Fernandes</p>', result);
     });
+
+    it('should allow templates to be overridden with uncompiled templates', function() {
+      var emptyDiffTemplate = '<p></p>';
+
+      var config = {rawTemplates: {'generic-empty-diff': emptyDiffTemplate}};
+      var hoganUtils = new (require('../src/hoganjs-utils.js').HoganJsUtils)(config);
+      var result = hoganUtils.render('generic', 'empty-diff', {myName: 'Rodrigo Fernandes'});
+      assert.equal('<p>Rodrigo Fernandes</p>', result);
+    });
+
+    it('should allow templates to be overridden giving priority to compiled templates', function() {
+      var emptyDiffTemplate = HoganJsUtils.compile('<p></p>');
+      var emptyDiffTemplateUncompiled = '<p>Not used!</p>';
+
+      var config = {
+        templates: {'generic-empty-diff': emptyDiffTemplate},
+        rawTemplates: {'generic-empty-diff': emptyDiffTemplateUncompiled}
+      };
+      var hoganUtils = new (require('../src/hoganjs-utils.js').HoganJsUtils)(config);
+      var result = hoganUtils.render('generic', 'empty-diff', {myName: 'Rodrigo Fernandes'});
+      assert.equal('<p>Rodrigo Fernandes</p>', result);
+    });
   });
 });

Image Slider

This is a simple image slider. It uses the Swiper library. Check the examples page for more information of what you can achieve with it.

Image Comparison Slider

This is a simple image comparison slider. It uses the img-comparison-slider library. Check the examples page for more information of what you can achieve with it.