Skip to main content

​
Overview

The Spaced Repetition System automatically schedules revisions when you complete study topics. Based on scientifically-proven retention intervals, the system ensures you review material at optimal times for long-term memory consolidation.
Default revision intervals: 1, 7, 30, and 90 days after initial completion. These intervals are fully customizable in Settings.

​
How It Works

​
Automatic Scheduling

When you mark a topic as “Finalizado” in the Session Registration modal: 
// Revision scheduling trigger (registro-sessao.js:651-668)
if (statusTopico === 'finalizado' && discId) {
  const d = getDisc(discId);
  if (d && assId) {
    const ass = d.disc.assuntos.find(a => a.id === assId);
    if (ass && !ass.concluido) {
      ass.concluido = true;
      ass.dataConclusao = todayStr();
      ass.revisoesFetas = [];
    }
  }
}
The system immediately calculates 4 revision dates: 
// Revision date calculation (logic.js:231-246)
export function calcRevisionDates(dataConclusao, feitas, adiamentos = 0) {
  const freqs = state.config.frequenciaRevisao || [1, 7, 30, 90];
  const base = new Date(dataConclusao + 'T00:00:00');
  base.setDate(base.getDate() + adiamentos); // Apply postponements
  
  const dates = freqs.slice(feitas.length).map(d => {
    const dt = new Date(base);
    dt.setDate(dt.getDate() + d);
    return getLocalDateStr(dt);
  });
  
  return dates;
}

​
Revision States

Each topic can have:
  • Not Started: concluido: false
  • Completed: concluido: true, dataConclusao: '2026-03-03'
  • Revisions Pending: Has future revision dates
  • Revisions Overdue: Revision date is less than today
  • All Revisions Done: revisoesFetas.length === 4

​
Revisions Interface

​
Summary Cards

Four stat cards at the top show: 
// Statistics (views.js:880-902)
const pending = getPendingRevisoes();
const upcoming = getUpcomingRevisoes(30);

// Pendentes Hoje: Revisions due today or overdue
pending.filter(r => r.data <= today).length

// Próx. 30 dias: Upcoming revisions in next month
upcoming.length

// Assuntos Concluídos: Total completed topics
getAllDisciplinas().reduce((s, { disc }) => 
  s + disc.assuntos.filter(a => a.concluido).length, 0)

// Frequência: Current interval configuration
(state.config.frequenciaRevisao || [1, 7, 30, 90]).join(', ') + ' dias'

​
Tabs

​
1. Pendentes Tab

Shows all overdue and today’s revisions: 
// Pending revisions (logic.js:251-271)
export function getPendingRevisoes() {
  const today = todayStr();
  const pending = [];
  
  for (const edital of state.editais) {
    for (const disc of (edital.disciplinas || [])) {
      for (const ass of disc.assuntos) {
        if (!ass.concluido || !ass.dataConclusao) continue;
        
        const revDates = calcRevisionDates(
          ass.dataConclusao, 
          ass.revisoesFetas || [], 
          ass.adiamentos || 0
        );
        
        for (const rd of revDates) {
          if (rd <= today) {
            pending.push({ assunto: ass, disc, edital, data: rd });
            break; // Only show next pending revision
          }
        }
      }
    }
  }
  
  return pending;
}
Each pending item displays:
  • Revision number badge (1ª, 2ª, 3ª, 4ª)
  • Topic name
  • Discipline and exam (edital)
  • Status: “Atrasada” (overdue) or “Hoje” (today)
  • Scheduled date
  • Action buttons: ”✅ Feita” and ”⏩ +1 dia”

​
2. Próximas 30 Dias Tab

Shows upcoming revisions for planning: 
// Upcoming revisions (views.js:855-877)
export function getUpcomingRevisoes(days = 30) {
  const today = todayStr();
  const future = new Date();
  future.setDate(future.getDate() + days);
  const futureStr = getLocalDateStr(future);
  
  const upcoming = [];
  
  for (const edital of state.editais) {
    for (const disc of (edital.disciplinas || [])) {
      for (const ass of disc.assuntos) {
        if (!ass.concluido || !ass.dataConclusao) continue;
        
        const revDates = calcRevisionDates(
          ass.dataConclusao, 
          ass.revisoesFetas || [], 
          ass.adiamentos || 0
        );
        
        for (const rd of revDates) {
          if (rd > today && rd <= futureStr) {
            upcoming.push({
              assunto: ass, 
              disc, 
              edital, 
              data: rd, 
              revNum: (ass.revisoesFetas || []).length + 1 
            });
            break;
          }
        }
      }
    }
  }
  
  return upcoming.sort((a, b) => a.data.localeCompare(b.data));
}

​
Actions

​
Marking as Done

// Mark revision complete (views.js:976-990)
export function marcarRevisao(assId) {
  for (const edital of state.editais) {
    for (const disc of (edital.disciplinas || [])) {
      const ass = disc.assuntos.find(a => a.id === assId);
      if (ass) {
        if (!ass.revisoesFetas) ass.revisoesFetas = [];
        ass.revisoesFetas.push(todayStr());
        scheduleSave();
        renderCurrentView();
        showToast('Revisão registrada!', 'success');
        return;
      }
    }
  }
}
Marking a revision as done adds today’s date to revisoesFetas[] and automatically schedules the next revision in the sequence.

​
Postponing Revisions

// Postpone revision by 1 day (views.js:992-1007)
export function adiarRevisao(assId) {
  for (const edital of state.editais) {
    for (const disc of (edital.disciplinas || [])) {
      const ass = disc.assuntos.find(a => a.id === assId);
      if (ass) {
        if (!ass.adiamentos) ass.adiamentos = 0;
        ass.adiamentos = (ass.adiamentos || 0) + 1;
        scheduleSave();
        renderCurrentView();
        showToast('Revisão adiada por 1 dia', 'info');
        return;
      }
    }
  }
}
Each postponement shifts all future revisions by 1 day. Use sparingly to avoid disrupting your schedule.

​
Using the Revision System

1

Complete a Topic

In the Study Organizer, finish studying a topic and click ”✅ Marcar como Estudei”. In the Session Registration modal, set “Status do tópico” to Finalizado nesta sessão.
2

View Scheduled Revisions

Navigate to Revisões in the sidebar. Your completed topic now appears in the “Próximas 30 dias” tab with its first revision scheduled for tomorrow (1-day interval).
3

Complete Revisions on Time

When a revision becomes due, it moves to the “Pendentes” tab. Click ”✅ Feita” to mark it complete and schedule the next interval.
4

Manage Overdue Items

Overdue revisions show a red “⚠️ Atrasada” badge. Either complete them immediately or postpone by 1 day using ”⏩ +1 dia”.
5

Track Progress

Monitor your revision completion rate in the summary cards. Aim for zero pending revisions daily.

​
Customizing Intervals

Change revision intervals in Settings: 
// Configuration structure
state.config.frequenciaRevisao = [1, 7, 30, 90]; // Default

// Alternative configurations:
// Conservative: [1, 3, 7, 14, 30, 60]
// Aggressive: [1, 7, 21, 60]
// Medical school: [1, 7, 15, 30, 90, 180]
Changing intervals only affects newly completed topics. Existing revision schedules remain unchanged.

​
Data Structure

​
Topic Object

// Assunto with revision data
{
  id: 'ass_1234567890',
  nome: 'Direitos Fundamentais - Art. 5º',
  concluido: true,
  dataConclusao: '2026-03-01', // Date marked as completed
  revisoesFetas: [
    '2026-03-02', // 1st revision (1 day)
    '2026-03-08'  // 2nd revision (7 days)
  ],
  adiamentos: 0 // Number of times postponed
}

​
Revision Item

// Pending/upcoming revision structure
{
  assunto: { /* topic object */ },
  disc: { /* discipline object */ },
  edital: { /* exam object */ },
  data: '2026-03-03', // Scheduled revision date
  revNum: 3 // Revision number (1-4)
}

​
Performance Optimization

​
Caching

Revision dates are cached to avoid recalculation: 
// Cache system (logic.js:228-230)
export const _revDateCache = new Map();
export function invalidateRevCache() { _revDateCache.clear(); }

export function calcRevisionDates(dataConclusao, feitas, adiamentos = 0) {
  const cacheKey = `${dataConclusao}:${feitas.length}:${adiamentos}:${freqs.join(',')}`;
  if (_revDateCache.has(cacheKey)) return _revDateCache.get(cacheKey);
  
  // ... calculate dates
  _revDateCache.set(cacheKey, dates);
  return dates;
}

​
Pending Cache

// Pending revisions cache (logic.js:248-250)
export let _pendingRevCache = null;
export function invalidatePendingRevCache() { _pendingRevCache = null; }

export function getPendingRevisoes() {
  if (_pendingRevCache) return _pendingRevCache;
  // ... calculate
  _pendingRevCache = pending;
  return pending;
}
Caches are invalidated when events change status or when topics are marked complete.

​
Integration with Other Features

​
Dashboard

Revision completion counts appear in the Dashboard under “Revisão” habit type.

​
Calendar

Revisions do not automatically create calendar events, but you can manually add revision sessions to the calendar.

​
Notifications

Browser notifications (if enabled) can alert you when revisions are due: 
// Example notification (not in current code, but easy to add)
if (pending.length > 0 && Notification.permission === 'granted') {
  new Notification('Revisões Pendentes', {
    body: `Você tem ${pending.length} revisão(s) para hoje!`,
    icon: 'favicon.ico'
  });
}

​
Best Practices

Check the Revisões tab every morning. Aim to complete all pending revisions before starting new study sessions.
Group revisions by discipline. For example, review all Constitutional Law topics in one session for better context retention.
Don’t just re-read material. Test yourself, create flashcards, or solve related questions during revision sessions.
If you struggle during a revision, add notes in the Session Registration modal and consider creating a new study event for that topic.
Limit postponements to genuine emergencies. Frequent delays defeat the purpose of spaced repetition.

​
Scientific Background

The default intervals (1, 7, 30, 90 days) are based on the Ebbinghaus Forgetting Curve and optimized for Brazilian civil service exam preparation:
  • Day 1: First review captures 70-80% retention before significant decay
  • Day 7: Second review at the point of maximum forgetting
  • Day 30: Consolidates into long-term memory
  • Day 90: Final reinforcement for permanent retention

​
Troubleshooting

Ensure you marked the topic as “Finalizado” in the Session Registration modal. Check that ass.concluido === true and ass.dataConclusao exists.
Verify your config.frequenciaRevisao settings. Clear the revision cache by calling invalidateRevCache() in the browser console.
This is a bug if the same topic appears multiple times. The system should only show the next pending revision. Report this issue.

Build docs developers (and LLMs) love

Get started for freeTalk to us