
Ref: Internet/AI Tools
Dec 08
Below is a blog-ready, copyright-free, plagiarism-free article on the ABC LD Toolkit and Arena Blended Connected (ABC) Learning Design, written in a clear, professional, and accessible tone.
Designing an engaging course is no longer about simply selecting content and sequencing topics. Today’s learners expect active participation, meaningful tasks, and an experience that blends digital and face-to-face learning in a seamless way. The ABC Learning Design Toolkit, also known as the Arena Blended Connected (ABC) Learning Design model, has become one of the most practical and widely adopted frameworks for educators who need a fast, collaborative, and highly visual approach to course design.
Whether you’re building a new course from scratch or redesigning an existing one, the ABC LD Toolkit provides a structured way to align learning outcomes, activities, and assessments—while keeping students at the heart of the design.
ABC Learning Design is a rapid, co-design method originally developed at University College London (UCL). The goal is simple:
Help educators design engaging, blended learning experiences in 90 minutes.
It uses a storytelling approach, visual activity cards, and collaborative design steps to map out an entire module or course. The focus is on how students learn rather than just what teachers teach.
ABC is built on Professor Diana Laurillard’s Conversational Framework, which emphasizes learning as an active, iterative dialogue between learners, teachers, peers, and the learning environment.
ABC stands for:
This approach helps curriculum teams work together—sometimes for the first time—to make design decisions visually and quickly.
The ABC LD Toolkit relies on six types of learning activities, each represented by a colour-coded activity card. These categories help instructors create a balanced, student-centred learning experience.
Students absorb content through readings, videos, demonstrations, or lectures.
Common examples: textbook chapters, micro-lectures, podcasts.
Learners exchange ideas, debate concepts, and collaborate.
Examples: forums, breakout groups, peer feedback.
Students try out skills in realistic, authentic contexts.
Examples: coding exercises, simulations, case studies.
Learners explore, research, or analyze information on their own.
Examples: data analysis tasks, research activities, inquiry-based learning.
Students work together to create something or solve a problem.
Examples: group projects, team case studies, collaborative documents.
Learners generate output that demonstrates understanding.
Examples: presentations, reports, multimedia artifacts, code submissions.
These categories help instructors avoid over-reliance on lectures and ensure that students engage through multiple pathways—a key component of active learning and Universal Design for Learning (UDL).
ABC Learning Design is typically done in a short but intensive workshop, usually 60–90 minutes. The process includes:
Participants agree on the overall learning outcomes for the course or module.
Using the activity cards, instructors design the sequence of learning events, week-by-week or unit-by-unit.
For blended or hybrid courses, the toolkit helps ensure that each activity uses the right modality.
The team identifies formative and summative assessments and links them directly to outcomes and activities.
The final output is a visual storyboard showing the entire course, making it easy to identify gaps, overload, or opportunities for improvement.
Once the design is approved, the storyboard becomes the blueprint for building the course in platforms like Blackboard, Brightspace, Moodle, or Canvas.
Design that would normally take weeks can be completed in an afternoon.
It prevents “content dumping” and supports purposeful, high-quality learning.
The toolkit helps instructors shift from passive lecture-heavy teaching to interactive, student-centred learning.
Perfect for modern post-secondary environments where digital learning is standard.
The card-based design makes the process tangible and easy to follow—even for instructors with little instructional design experience.
Many colleges and polytechnics—including those in Canada—are adopting ABC LD as part of their curriculum renewal and digital learning strategies. It brings academic program managers, instructors, designers, and support teams together to build courses that are consistent, accessible, and aligned with institutional standards.
ABC is especially powerful when paired with:
The result is a teaching and learning environment that supports clarity, consistency, and student success.
The ABC Learning Design Toolkit is more than just an instructional design method—it is a collaborative philosophy that puts students at the centre of the learning experience. By simplifying course design and encouraging active learning, ABC helps educators create meaningful, blended learning environments that are engaging, efficient, and academically sound.
For instructors, program leaders, and institutions looking to modernize teaching practices, ABC LD offers a proven, practical, and accessible framework that can transform how courses are built and delivered.
Dec 02
Below is a 30–40 minute SMTP lesson plan suitable for college-level networking courses . It includes: purpose, tools, installations, commands, protocol operations, Telnet interaction, data formats, and references to typical Wireshark visuals (without reproducing copyrighted images).
Topic: Simple Mail Transfer Protocol (SMTP)
Audience: Networking / IT Students
Goal: Understand SMTP purpose, workflow, commands, install & test SMTP on Ubuntu, and observe the protocol using Telnet & Wireshark.
| Tool | Purpose |
|---|---|
| Ubuntu Server | Install and run SMTP daemon (Postfix). |
| Telnet or Netcat | Manual SMTP interaction. |
| Wireshark | Capture & analyze SMTP packets. |
| DNS Tools (dig/nslookup) | Check MX records for mail routing. |
sudo apt update
sudo apt install postfix
When prompted:
yourdomain.test (or localhost)sudo systemctl status postfix
sudo ss -tlnp | grep 25
sudo tail -f /var/log/mail.log
SMTP uses simple ASCII-based commands.
You can refer to standard diagrams online (e.g., RFC 5321 command flow), which show:
Client → Server commands
Server → Client status codes
| Command | Purpose |
|---|---|
| HELO / EHLO | Identify client (EHLO supports extensions). |
| MAIL FROM: | Sender envelope address. |
| RCPT TO: | Recipient address. |
| DATA | Begins message content. |
| QUIT | Close connection. |
| RSET | Reset session. |
| VRFY | Verify user existence (often disabled). |
| Code | Meaning |
|---|---|
| 220 | Server ready |
| 250 | OK |
| 354 | Start message input |
| 421 | Service unavailable |
| 550 | Mailbox unavailable |
| 551 | User not local |
| 552–554 | Message rejected |
Reference:
Online SMTP diagrams typically show a vertical message exchange: client commands on left, server replies on right, with arrows showing flow.
220250 OK250 OK354 End with <CRLF>.<CRLF>.This is the “Envelope + Content” model.
telnet localhost 25
Connected to localhost.
220 mail.yourdomain.test ESMTP Postfix
EHLO client.test
250-mail.yourdomain.test
250-PIPELINING
250-SIZE 10240000
250-STARTTLS
250-ENHANCEDSTATUSCODES
250 8BITMIME
MAIL FROM:<alice@client.test>
250 2.1.0 Ok
RCPT TO:<bob@server.test>
250 2.1.5 Ok
DATA
354 End data with <CR><LF>.<CR><LF>
Subject: Test Email
From: alice@client.test
To: bob@server.test
Hello Bob,
This is a test sent via raw SMTP.
.
250 2.0.0 Ok: queued as XYZ123
QUIT
221 2.0.0 Bye
. terminates DATA mode.mailq
sudo postsuper -d ALL
Students can search for diagrams of:
MAIL FROM: <sender@example.com> ← Envelope
RCPT TO: <receiver@example.com> ← Envelope
--- Data Section ---
Subject: Meeting Tomorrow
From: Sender <sender@example.com>
To: Receiver <receiver@example.com>
Date: Tue, 02 Dec 2025 13:15:00 -0500
Hello,
This is the body of the message.
Key concepts:
Tell students to search:
“Wireshark SMTP packet details” images
These images typically show:
Application Layertcp.port == 25
smtp
Students will notice:
sendmail or mail command.Below is (1) a clean, professional ASCII diagram of the full SMTP flow, and (2) a fully structured SMTP Lab Assignment with step-by-step tasks for students.
Everything is original, copyright-free
This diagram shows the complete sequence between Mail User Agent (MUA), Mail Submission Agent (MSA), Mail Transfer Agent (MTA), and Mail Delivery Agent (MDA).
+------------------+
| User Client |
| (MUA: Thunderbird,
| Outlook, etc.)|
+--------+---------+
|
| SMTP Submission (Port 587)
v
+------------------+
| MSA (Postfix) |
| Mail Submission |
+--------+---------+
|
| SMTP Relay (Port 25)
v
----------------------------------------------------------------
| Internet (Multiple MTAs) |
| |
| +------------------+ +------------------+ |
| | MTA #1 | ---> | MTA #2 | ---> ... |
| | Mail Transfer | | Mail Transfer | |
| +------------------+ +------------------+ |
----------------------------------------------------------------
|
| SMTP Delivery (Port 25)
v
+------------------+
| MDA (Local Mail |
| Delivery Agent) |
| e.g., Dovecot |
+--------+---------+
|
| Stores message
v
+------------------+
| User Mailbox |
+------------------+
|
| IMAP/POP Retrieval
v
+------------------+
| Recipient MUA |
+------------------+
Client → 220 Server Ready
Client → EHLO client.example
Server → 250-Server features
Client → MAIL FROM:<alice@example.com>
Server → 250 OK
Client → RCPT TO:<bob@example.com>
Server → 250 OK
Client → DATA
Server → 354 End with <CRLF>.<CRLF>
Client → (headers + message body)
Client → .
Server → 250 Message Queued
Client → QUIT
Server → 221 Goodbye
Lab Duration: 45–60 minutes
Environment: Ubuntu Server + GNS3 VM or physical system
Learning Outcomes:
sudo apt update
sudo apt install postfix
During setup:
labmail.testsudo systemctl status postfix
sudo ss -tlnp | grep 25
You will manually simulate an email client by using Telnet to speak SMTP commands to the server.
sudo apt install telnet
telnet localhost 25
You should see:
220 labmail.test ESMTP Postfix
EHLO student.test
Expected:
250-labmail.test
250-PIPELINING
250-SIZE 10240000
250-STARTTLS
250 8BITMIME
MAIL FROM:<alice@student.test>
250 OK
RCPT TO:<bob@student.test>
250 OK
DATA
354 End data with <CRLF>.<CRLF>
Subject: Lab SMTP Test
From: Alice <alice@student.test>
To: Bob <bob@student.test>
Hello Bob,
This is a test email sent manually using SMTP.
.
Server should reply:
250 OK: queued as ABC123
QUIT
221 Bye
mailq
sudo tail -f /var/log/mail.log
sudo postsuper -d ALL
Use interface: lo (loopback) or eth0 depending on lab setup.
SMTP filter:
smtp
Or:
tcp.port == 25
Wireshark will show:
EHLO, MAIL, RCPT, DATA.Students answer the following:
(Expect: EHLO identifies client and requests extended SMTP features.)
(Expect: Envelope controls routing; DATA contains RFC 5322 email.)
<CRLF>.<CRLF> to end data?(Expect: SMTP is plaintext without TLS.)
Show how encrypted SMTP prevents Wireshark from reading content.
Use dig MX to observe mail routing.
Nov 30
Asked ChatGPT:
I want to see which index ETF/fund performed as well as Bitcoin over the previous 10 years or 20 years. 2. How do XIT, QQQ, or Similar, S&P 500, FBTC compare with bitcoin performance? The primary concern is growth and gain. Volatility is a different concern, which is not currently the primary concern.
Great — I’ll answer both parts clearly and compactly, with numbers and sources so you can act on them.
Short answer (headline):
Over the past ~10 years nothing in the major index/ETF world comes close to Bitcoin’s raw price performance — Bitcoin blew past even the best tech ETFs. The closest high-growth ETF (QQQ) returned strong equity gains but was far below Bitcoin. For 20 years you can’t meaningfully compare because Bitcoin doesn’t have a 20-year history.
Below I give a short comparison (table + commentary), the important caveats, and a practical takeaway for your decisions.
1) Quick comparison (growth focus — trailing figures / approximate CAGRs)
Time window: where possible I use 10-year trailing/typical published figures. Where a product is newer (FBTC) I note since-inception or latest trailing returns. All figures are pulled from market sources (links below each block).
| Asset / ETF | Representative trailing CAGR (≈10y) or note | Source |
| Bitcoin (BTC) | ~+70–75% p.a. (10-yr CAGR) — enormous outperformance vs stocks over the last decade. | casebitcoin / Bitcoin CAGR charts (summary of historical CAGR). (The Case for Bitcoin) |
| Invesco QQQ (QQQ) | ~+19% p.a. (10-yr total-return CAGR) — very strong, tech-heavy growth ETF but far below BTC. | financecharts / QQQ total-return metrics. (FinanceCharts) |
| S&P 500 (broad US) | ~+12–13% p.a. (10-yr CAGR) — long-run strong equity returns but well below QQQ and Bitcoin. | long-run S&P data / macrotrends / index backtests. (Curvo) |
| iShares S&P/TSX Capped Information Tech (XIT.TO) | Trailing performance is strong (multi-year gains), but not comparable to BTC over 10y; typical multi-yr numbers are high in recent years (e.g., 1-3-5y strong). See broker pages for exact trailing figures. | BlackRock / Yahoo Finance performance pages. (BlackRock) |
| Fidelity Advantage Bitcoin ETF (FBTC.TO) | Fund inception: 30-Nov-2021 — too young for 10-yr comparison. Since inception & 1-yr figures show meaningful BTC-like returns in good years (e.g., 1-yr +60% in last 12m), but its track record only stretches back to 2021. | Fidelity ETF factsheet / Yahoo. (Fidelity Investments Canada) |
Key numbers (for emphasis): casebitcoin’s roll-up shows BTC 10-yr CAGR roughly in the 70%-plus range vs S&P500 ~13% and QQQ ~19% over roughly the same 10-year span. That gap explains why many investors say “Bitcoin crushed everything over the last decade.” (The Case for Bitcoin)
2) Important caveats & why direct comparisons are tricky
3) How XIT / QQQ / S&P / FBTC stack up vs Bitcoin (plain language)
4) Practical takeaways for you (growth-focused)
5) Sources & where I pulled numbers (most important references)
6) If you want next steps (I can do any of these now)
Which one would you like me to run next? (I can make the chart/table right now.)
Produce a side-by-side chart of cumulative returns (log scale) for BTC, QQQ, S&P500 and XIT for the last 10 years.
Show CAGR numbers for 1/3/5/10 years in a neat table (with exact dates you pick).
Run a risk-adjusted comparison (Sharpe, max drawdown) so you can judge growth relative to volatility.
Below is a polished, blog-ready article that does everything you asked — a clear explanation, the exact reproducible Python code you can run to produce the side-by-side cumulative returns chart (log scale) and the CAGR / Sharpe / max-drawdown table, and an interpretation of what the results mean. I can run the code and produce the charts/tables for you if you want me to fetch live data — say the word and I’ll pull the latest prices and run it. For now I provide the ready-to-run script + commentary so you (or I) can generate exact numbers and visuals.
BTC vs QQQ vs S&P500 vs XIT — 10-Year Performance, CAGR & Risk-Adjusted Comparison
(reproducible — run the code to fetch live data and recreate charts/tables)
What this piece contains
1) Summary & approach (quick)
You asked for a side-by-side comparison of Bitcoin (BTC), QQQ (Nasdaq-100 ETF), S&P 500 (SPY as proxy), and XIT (Canadian tech ETF) over the last 10 years — with CAGRs for 1, 3, 5 and 10 years, and risk-adjusted metrics (Sharpe, max drawdown).
Approach:
2) The exact Python script (run this locally or ask me to run it)
Requirements: Python 3.8+, yfinance, pandas, numpy, matplotlib, scipy (optional).
Install if needed: pip install yfinance pandas numpy matplotlib scipy
# btc_vs_equities_performance.py
# Reproducible script to produce:
# – log-scale cumulative returns chart for BTC, QQQ, SPY, XIT (10 years)
# – CAGR table for 1/3/5/10 years (exact dates)
# – Risk-adjusted metrics: Annualized Sharpe, Annualized Volatility, Max Drawdown
#
# Usage: python btc_vs_equities_performance.py
# (or run each cell in a Jupyter Notebook)
import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime, timedelta
# ———————–
# User-configurable:
tickers = {
“Bitcoin”: “BTC-USD”,
“QQQ”: “QQQ”,
“S&P500 (SPY)”: “SPY”,
“XIT (TSX Tech)”: “XIT.TO” # change if your broker uses a different suffix
}
end_date = pd.to_datetime(“today”).normalize() # or set explicit e.g. pd.to_datetime(“2025-11-28”)
start_date = end_date – pd.DateOffset(years=10) # 10 years back
risk_free_rate_annual = 0.03 # example: 3% annual risk-free (adjust if you prefer)
trading_days = 252
# ———————–
# Fetch data
def fetch_close_prices(tickers, start, end):
data = yf.download(list(tickers.values()), start=start.strftime(“%Y-%m-%d”),
end=(end + pd.Timedelta(days=1)).strftime(“%Y-%m-%d”),
progress=False)[“Adj Close”]
data.columns = list(tickers.keys())
return data.dropna(how=”all”)
prices = fetch_close_prices(tickers, start_date, end_date)
if prices.isnull().any().any():
prices = prices.fillna(method=’ffill’).dropna(how=’all’) # simple fill-forward
# ———————–
# Compute daily returns
returns = prices.pct_change().dropna()
# Cumulative returns (log scale for plotting)
cum_returns = (1 + returns).cumprod()
# ———————–
# Functions for metrics
def annualized_return_from_period(start_price, end_price, n_years):
return (end_price / start_price) ** (1.0 / n_years) – 1.0
def compute_cagr(series, start_date, end_date):
# series is price series (pandas Series)
p0 = series.loc[start_date]
p1 = series.loc[end_date]
days = (end_date – start_date).days
years = days / 365.25
return (p1 / p0) ** (1.0 / years) – 1.0
def annualized_volatility(daily_ret):
return daily_ret.std() * np.sqrt(trading_days)
def sharpe_ratio(daily_ret, rf_annual=0.03):
excess_daily = daily_ret – (rf_annual / trading_days)
ann_excess = excess_daily.mean() * trading_days
ann_vol = annualized_volatility(daily_ret)
if ann_vol == 0:
return np.nan
return ann_excess / ann_vol
def max_drawdown(price_series):
running_max = price_series.cummax()
drawdown = (price_series – running_max) / running_max
return drawdown.min() # negative number
# ———————–
# Prepare CAGR windows (end dates inclusive)
end = prices.index[-1]
windows = {
“1Y”: end – pd.DateOffset(years=1),
“3Y”: end – pd.DateOffset(years=3),
“5Y”: end – pd.DateOffset(years=5),
“10Y”: end – pd.DateOffset(years=10)
}
# Align window start dates to nearest available index
def align_date(series_index, dt):
# choose the first available index on or after dt
idx = series_index[series_index >= dt]
if len(idx) == 0:
return series_index[0]
return idx[0]
cagr_table = []
metrics_table = []
for name in prices.columns:
series = prices[name]
daily = returns[name]
# CAGR for windows
cagr_row = {“Instrument”: name}
for label, dt in windows.items():
start_aligned = align_date(prices.index, dt)
try:
cagr = compute_cagr(series, start_aligned, end)
except Exception as e:
cagr = np.nan
cagr_row[label] = cagr
cagr_row[f”{label}_start_date”] = start_aligned.date()
cagr_table.append(cagr_row)
# Risk metrics (annualized)
ann_vol = annualized_volatility(daily)
sr = sharpe_ratio(daily, risk_free_rate_annual)
md = max_drawdown(series)
metrics_table.append({
“Instrument”: name,
“Annualized Volatility”: ann_vol,
“Sharpe (ann.)”: sr,
“Max Drawdown”: md
})
cagr_df = pd.DataFrame(cagr_table).set_index(“Instrument”)
metrics_df = pd.DataFrame(metrics_table).set_index(“Instrument”)
# ———————–
# Plot log-scale cumulative returns (normalized to 1 at the start of the plotted period)
plt.style.use(‘seaborn-darkgrid’)
plt.figure(figsize=(12,6))
# Normalize each series to 1 at the first date
normed = prices / prices.iloc[0]
for col in normed.columns:
plt.plot(normed.index, np.log(normed[col]), label=col) # log scale by plotting log of normed
plt.legend()
plt.title(“Log Cumulative Returns (normalized) — BTC vs QQQ vs SPY vs XIT”)
plt.xlabel(“Date”)
plt.ylabel(“Log of Normalized Price (log scale equivalent)”)
plt.tight_layout()
plt.show()
# ———————–
# Present table outputs
pd.set_option(‘display.float_format’, ‘{:.2%}’.format)
print(“\nCAGR Table (exact windows):”)
display_cagr = cagr_df.copy()
display_cagr = display_cagr[[c for c in [“1Y”, “3Y”, “5Y”, “10Y”] if c in display_cagr.columns]]
print(display_cagr)
print(“\nRisk Metrics (annualized):”)
print(metrics_df)
# Save results to CSV for convenience
cagr_df.to_csv(“cagr_table.csv”)
metrics_df.to_csv(“risk_metrics.csv”)
normed.to_csv(“normalized_prices.csv”)
print(“\nSaved cagr_table.csv, risk_metrics.csv, normalized_prices.csv”)
3) How the code works & exact dates
4) Interpreting the results (what to expect when you run it)
When you run the script you will get:
Typical historical patterns you’re likely to see (once you run it):
5) Example of how to read the final table
After running, you might see something like (illustrative only — run script for real numbers):
| Instrument | 1Y CAGR | 3Y CAGR | 5Y CAGR | 10Y CAGR | Ann Vol | Sharpe | Max Drawdown |
| Bitcoin | 35% | 75% | 80% | 120% | 90% | 0.6 | -0.80 |
| QQQ | 20% | 30% | 25% | 18% | 25% | 0.9 | -0.50 |
| SPY | 12% | 18% | 16% | 12% | 18% | 0.8 | -0.34 |
| XIT | 8% | 12% | 10% | 7% | 22% | 0.45 | -0.60 |
These numbers are for illustration only — run the script to get exact, up-to-date numbers and a nice chart.
6) Plain English takeaways (what the results mean)
7) Next steps I can do for you (pick one)
Which would you like? A, B, or C? (If you want A or B please confirm you want live data fetched now.)
Nov 28
| ETF | What works in favor | What to worry about / risk |
|---|---|---|
| SPSK (Sukuk-based) | Fixed-income–like behavior → lower volatility; income yield; relatively stable under different equity/real-estate cycles; halal-compliant structure. | Yield is modest; upside (capital gain) limited compared to equity/REIT; currency risk if USD-denominated and you hold in CAD; income/yield dependent on global sukuk market and interest-rate environment. |
| SPRE (Global REIT) | Offers dividend yield + potential capital upside if real estate markets improve; global geographic diversification via many REITs; historically REITs tend to do well when rates ease or stabilize. | Higher sensitivity to interest rates and global economic cycles; global real estate & currency risk; more volatile — price swings can be larger; income yield + price risk trade-off. |
If I were you and investing $5,000 CAD right now, I would choose SPRE — but with the expectation that it’s more speculative than SPSK, and only commit a portion (maybe 70-80%) of the $5,000 to SPRE — leaving remainder (or other cash) aside or used elsewhere.
Why SPRE
With caveats / risk mitigation
Alternatively, if my priority were capital preservation and steady income, and I were less tolerant of volatility, then SPSK would be the safer, more conservative pick.
Nov 28
Here’s my take on whether SPRE is a good purchase today — what looks good, what to watch out for, and under what conditions I would buy it. Use this as a thought exercise (or blog-ready summary), not as investment advice. By ChatGPT
In short: if you believe global real estate income stays stable, and interest rates or macroeconomic conditions remain relatively benign — SPRE offers a mix of yield, diversification, and moderate risk.
I consider SPRE a reasonable “core+income” holding — especially if you want real-estate exposure with a global and Shariah-compliant tilt. I would consider buying today if:
I’d treat SPRE as a “complementary slice” — not the backbone, but part of a broader asset mix.
If I were building or adjusting a portfolio today:
Yes — SPRE can be a good purchase today, if your goal is to build a diversified, income-oriented, slightly conservative portfolio rather than chase aggressive growth. It’s not a “get-rich-fast” asset, but a more stable, income-producing, globally diversified real-estate slice.
Nov 28
The SP Funds Dow Jones Global Sukuk ETF (SPSK) has become one of the most popular halal-compliant fixed-income ETFs available to North American investors. For those seeking stable income, lower volatility than equities, and adherence to Islamic finance principles, SPSK deserves serious consideration. But is today a good time to buy it?
SPSK invests in global sukuk — asset-backed certificates structured under Islamic finance rules. These securities avoid interest (riba) and are backed by tangible assets, making them suitable for investors seeking Shariah-compliant fixed-income exposure.
Sukuk behave similarly to short–to–intermediate-term bonds. That means smoother price movements and lower drawdowns compared with stock markets, a useful stabilizer in a diversified portfolio.
Recent yield levels have hovered in the 3%–4% range depending on market conditions and share class. This makes SPSK an appealing source of steady income while maintaining halal compliance.
Sukuk generally exhibit lower duration risk than long-duration government bonds. SPSK tends to react less dramatically to interest-rate shocks, reducing the risk of sharp price swings.
SPSK follows the Dow Jones Sukuk Index and uses institutional-grade custody for its underlying holdings. For investors who want long-term stability in their fixed-income sleeve, this structure is attractive.
Most sukuk issuers come from the Gulf region, which means geographic and sector concentration. This limits diversification relative to global bond markets.
The sukuk market is smaller and newer than conventional bond markets. Investors may face wider bid-ask spreads during periods of stress.
SPSK trades in USD. For Canadian investors, returns will fluctuate based on CAD/USD movements.
Sukuk structures vary across jurisdictions. Changes in Islamic-finance regulations or issuer practices may affect valuations.
If interest rates decline sharply, yields across income products may compress, and sukuk returns may become less competitive in relative terms.
SPSK is a strong long-term income holding — but not a growth asset.
It works well when:
SPSK is best viewed as a steady, long-term anchor in a diversified portfolio. It is less suitable for short-term speculation or investors expecting high capital appreciation.
A practical allocation range is:
The ETF works particularly well in portfolios built around risk management, steady income, and ethical finance principles.
SPSK can be a strong addition to a long-term, halal-compliant portfolio. It provides stable income, lower volatility, and an ethical alternative to conventional bonds. While it carries concentration and liquidity risks, its income stability and Shariah-compliant structure make it appealing for long-term investors seeking conservative exposure.
Nov 28
Here is a polished, clean, copyright-free, plagiarism-free summary written as a blog-style post. by ChatGPT
When planning ahead for retirement or tax-sheltered investing, it’s common to wonder: “Can I contribute early for next year?” or “How much can I go over my limit without penalty?”
Here is a clear, simple breakdown of how TFSA and RRSP over-contribution rules actually work in Canada.
You cannot contribute today for next year’s TFSA room.
TFSA contribution room opens January 1st each year, and only then does the new limit become available.
📌 Example:
If you try to add your 2026 TFSA amount in November 2025, the CRA will charge a penalty for November and December because that room does not exist yet.
❌ You cannot pre-pay next year’s TFSA room.
✔ The safest move is to wait until January 1st to add the next year’s contribution.
RRSPs work differently. Unlike the TFSA, the RRSP offers a small “buffer.”
📌 Example:
If your contribution room is $10,000 and you contribute $13,000, you are $3,000 over.
The first $2,000 is forgiven, but the remaining $1,000 is taxed at 1% per month.
✔ You can go up to $2,000 over your limit without penalties.
❌ You cannot claim a deduction for that $2,000.
✔ Anything beyond that incurs monthly penalties.
| Feature | TFSA | RRSP |
|---|---|---|
| Can you pre-pay next year’s room? | ❌ No | ✔ Contribution timing is flexible, but must stay within limits |
| Penalty starts when? | Immediate excess → 1% per month | Only on excess above $2,000 |
| Allowed buffer | None | $2,000 lifetime allowance |
| When does new room open? | Jan 1 every year | Feb/March tax filing updates your room |
Both the TFSA and RRSP are powerful tax-sheltered tools, but the rules around contribution timing are strict.
Planning ahead is great, just make sure your contribution timing aligns with CRA rules to avoid unnecessary penalties.
Nov 26
Here is a clean, fully rewritten, plagiarism-free, blog-ready version that covers both the step-by-step tutorial and the architecture diagram explanation, merged into one smooth article.
You can publish this as-is.
How to Run the GNS3 VM Inside Oracle VirtualBox
A Complete Guide
GNS3 becomes far more powerful and efficient when paired with the GNS3 VM. Instead of your host machine running all routers, switches, and appliances, the load shifts into a dedicated virtual machine. While many users rely on VMware, you can run the GNS3 VM just as effectively using Oracle VirtualBox.
This guide walks you through importing the GNS3 VM OVA file, configuring VirtualBox, linking the VM to the GNS3 desktop client, and understanding how the network paths between each component work.
Step 1: Extract the GNS3 VM ZIP File
After downloading the GNS3 VM package for VirtualBox:
What is an OVA file?
It’s an “Open Virtualization Appliance,” a ready-to-run virtual machine packaged for import.
Step 2: Open Oracle VirtualBox
This prepares VirtualBox to load the GNS3 VM image.
Step 3: Select the OVA File
VirtualBox will show a summary of the machine it is about to import.
Step 4: Adjust the Import Settings
(Highly recommended for performance)
Before completing the import, review the resource allocation:
After reviewing, click Import. VirtualBox will create the VM automatically.
Step 5: Start the GNS3 VM
You should see its IP address and confirmation that the GNS3 backend services are running.
Step 6: Connect GNS3 to the VM
Next, tell your GNS3 desktop application to use the VM instead of running devices locally.
A successful configuration will show a message indicating that the GNS3 VM is detected and running.
How the Host, GNS3 VM, and VirtualBox Communicate
Understanding the communication path helps troubleshoot connectivity and device start-up issues.
+——————-+
| Host OS |
| (Windows/Linux) |
| |
| GNS3 GUI |
+———+———+
|
VirtualBox Host-Only Adapter
|
+———v———+
| GNS3 VM |
| (Ubuntu Core) |
| |
| Dynamips/QEMU |
| Routers/Switches |
+———+———+
|
Internal Networks for Lab Devices
|
+——–v——–+
| Virtual Routers |
| Virtual Switches|
| VPCS / PCs |
+—————–+
How the pieces interact:
1. GNS3 GUI on the Host OS
2. GNS3 VM running inside VirtualBox
3. VirtualBox Network Adapters
This architecture ensures that your host machine remains responsive while the VM handles networking workloads.
Final Thoughts
Running the GNS3 VM within Oracle VirtualBox is a powerful solution that avoids the need for VMware products while providing the same performance benefits. Once the VM is imported, configured, and linked with the GNS3 client, you can run large labs with routers, switches, firewalls, and servers — all inside a controlled virtual environment.
If you want, I can also prepare:
✅ A companion guide for configuring VirtualBox network adapters
✅ A troubleshooting section for common GNS3 VM errors
✅ A printable PDF version of this guide
Nov 26
To use classic Cisco routers such as the 3725 in your GNS3 labs, you’ll need the correct IOS image files. This guide explains where to find them, where to store them, and how to import them properly into GNS3.
Where to Store IOS Images in GNS3
GNS3 expects router images to be placed inside its dedicated IOS directory.
On Windows, the default path is:
C:\Users\<your-username>\GNS3\images\IOS
Simply drop your .bin, .image, or extracted IOS files into that folder.
If you received IOS files from another source (e.g., a .zip archive shared through Teams), extract them and place the contents into the images\IOS directory.
Where to Find Cisco Router Images
GNS3 provides a library of appliances and linked documentation. Cisco IOS images themselves are not distributed directly by GNS3, but some resources help guide the process.
A good starting point:
These resources walk through how to prepare and import older Cisco router images for lab use.
How to Import the Cisco 3725 Router Image Into GNS3
The following steps use the Dynamips engine inside GNS3.
Step 1: Open the IOS Router Import Wizard
Step 2: Select Your IOS Image
Step 3: Choose Router Platform & RAM
GNS3 will automatically suggest optimal values.
Step 4: Add Optional Hardware Modules
Depending on the lab you want to build, you can add modules to the router:
Common modules:
| Module | Purpose |
| NM-1FE-TX | Adds FastEthernet interfaces |
| NM-16ESW | Adds a 16-port switch module |
| WIC-2T | Creates serial interfaces (used for WAN labs) |
Add these in the Slots section of the import wizard.
Step 5: Set Idle-PC Value
Idle-PC prevents your CPU from spiking to 100%.
Step 6: Finish and Save the Template
Once completed, you now have a reusable router template inside GNS3.
Using the Cisco 3725 Router in Your Lab
(You can ignore this section unless your lab requires configuration.)
Add the Router to a Project
Basic Configuration Example
enable
configure terminal
hostname R1
interface FastEthernet0/0
ip address 192.168.1.1 255.255.255.0
no shutdown
end
write memory
show ip interface brief
Serial Interface Example (Router-to-Router Link)
interface Serial0/0
ip address 10.1.1.1 255.255.255.252
clock rate 64000 ! Use only on the DCE side
no shutdown
✅ Your Cisco 3725 Router Is Now Ready for Use in GNS3
Once imported, you can create topologies, experiment with routing protocols, practice WAN labs, or run switching features using the NM-16ESW module.