How to Apply Optimization Techniques in Practice

I've been building and deploying RAG systems for 2+ years. And it's taught me optimizing them requires focusing on 3 core stages: 1. Pre-Retrieval 2. Retrieval 3. Post-Retrieval Let me explain - Most people focus on the generation side of things. But optimizing retrieval is what really makes the difference. Here's how to do it: 𝟭/ 𝗣𝗿𝗲-𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 This is where we optimize the data before the retrieval process even begins. The goal? Structure your data for efficient indexing and ensure the query is as precise as possible before it's embedded and sent to your vector DB. Here’s how: - 𝗦𝗹𝗶𝗱𝗶𝗻𝗴 𝘄𝗶𝗻𝗱𝗼𝘄: 𝘐𝘯𝘵𝘳𝘰𝘥𝘶𝘤𝘦 𝘤𝘩𝘶𝘯𝘬 𝘰𝘷𝘦𝘳𝘭𝘢𝘱 𝘵𝘰 𝘳𝘦𝘵𝘢𝘪𝘯 𝘤𝘰𝘯𝘵𝘦𝘹𝘵 𝘢𝘯𝘥 𝘪𝘮𝘱𝘳𝘰𝘷𝘦 𝘳𝘦𝘵𝘳𝘪𝘦𝘷𝘢𝘭 𝘢𝘤𝘤𝘶𝘳𝘢𝘤𝘺. - 𝗘𝗻𝗵𝗮𝗻𝗰𝗶𝗻𝗴 𝗱𝗮𝘁𝗮 𝗴𝗿𝗮𝗻𝘂𝗹𝗮𝗿𝗶𝘁𝘆: 𝘊𝘭𝘦𝘢𝘯, 𝘷𝘦𝘳𝘪𝘧𝘺, 𝘢𝘯𝘥 𝘶𝘱𝘥𝘢𝘵𝘦 𝘥𝘢𝘵𝘢 𝘧𝘰𝘳 𝘴𝘩𝘢𝘳𝘱𝘦𝘳 𝘳𝘦𝘵𝘳𝘪𝘦𝘷𝘢𝘭. - 𝗠𝗲𝘁𝗮𝗱𝗮𝘁𝗮: 𝘜𝘴𝘦 𝘵𝘢𝘨𝘴 (𝘭𝘪𝘬𝘦 𝘥𝘢𝘵𝘦𝘴 𝘰𝘳 𝘦𝘹𝘵𝘦𝘳𝘯𝘢𝘭 𝘐𝘋𝘴) 𝘵𝘰 𝘪𝘮𝘱𝘳𝘰𝘷𝘦 𝘧𝘪𝘭𝘵𝘦𝘳𝘪𝘯𝘨. - 𝗦𝗺𝗮𝗹𝗹-𝘁𝗼-𝗯𝗶𝗴 (or parent) 𝗶𝗻𝗱𝗲𝘅𝗶𝗻𝗴: 𝘜𝘴𝘦 𝘴𝘮𝘢𝘭𝘭𝘦𝘳 𝘤𝘩𝘶𝘯𝘬𝘴 𝘧𝘰𝘳 𝘦𝘮𝘣𝘦𝘥𝘥𝘪𝘯𝘨 𝘢𝘯𝘥 𝘭𝘢𝘳𝘨𝘦𝘳 𝘤𝘰𝘯𝘵𝘦𝘹𝘵𝘴 𝘧𝘰𝘳 𝘵𝘩𝘦 𝘧𝘪𝘯𝘢𝘭 𝘢𝘯𝘴𝘸𝘦𝘳. - 𝗤𝘂𝗲𝗿𝘆 𝗼𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻: 𝘛𝘦𝘤𝘩𝘯𝘪𝘲𝘶𝘦𝘴 𝘭𝘪𝘬𝘦 𝘲𝘶𝘦𝘳𝘺 𝘳𝘰𝘶𝘵𝘪𝘯𝘨, 𝘲𝘶𝘦𝘳𝘺 𝘳𝘦𝘸𝘳𝘪𝘵𝘪𝘯𝘨, 𝘢𝘯𝘥 𝘏𝘺𝘋𝘌 𝘤𝘢𝘯 𝘳𝘦𝘧𝘪𝘯𝘦 𝘵𝘩𝘦 𝘳𝘦𝘴𝘶𝘭𝘵𝘴. 𝟮/ 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 The magic happens here. Your goal is to improve the embedding models and leverage DB filters to retrieve the most relevant data based on semantic similarity. - Fine-tune your embedding models or use instructor models like instructor-xl for domain-specific terms. - Use hybrid search to blend vector and keyword search for more precise results. - Use GraphDBs or multi-hop techniques to capture relationships within your data. 𝟯. 𝗣𝗼𝘀𝘁-𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 At this stage, your task is to filter out noise and compress the final context before sending it to the LLM. - Use prompt compression techniques. - Filter out irrelevant chunks to avoid adding noise to the augmented prompt (e.g., using reranking) 𝗥𝗲𝗺𝗲𝗺𝗯𝗲𝗿: RAG optimization is an iterative process. Experiment with various techniques, measure their effectiveness, compare them and refine them. Ready to step up your RAG game? Check out the link in the comments.

One of the most fascinating projects I have worked on eventually became US Patent… a system for multi-modal journey optimization. At first glance, it sounds straightforward: get a traveler from point A to point B as quickly as possible. But in reality, this is not a “shortest path” problem. It is a problem of navigating combinatorial explosion under uncertainty while still producing results that humans will actually use. The lesson was simple, but profound: a single “optimal” route is often the wrong answer. In practice, commuters do not blindly follow whatever the algorithm declares “fastest.” They balance hidden costs (number of transfers, reliability, waiting time) against raw travel time. A route that is one minute slower but has one fewer transfer will often be preferred. We approached this by abandoning the idea of returning just one solution. Instead, we designed an iterative search that keeps a fixed-length priority queue of candidate paths, pruning aggressively to keep the search tractable, but always preserving multiple high-quality alternatives. The output is a set of Pareto-efficient options: fast, but also different enough that a user can choose the one that fits their risk tolerance, comfort level, or schedule flexibility. This project shifted how I think about optimization. The real challenge isn’t mathematical purity, it is making decisions robust to the messiness of the real world. If the solution space is reduced to a single “optimal” point, you risk oversimplifying reality and delivering something no one wants to use. When we expose the trade-offs explicitly, we help people make better decisions.

With a background in data engineering and business analysis, I’ve consistently seen the immense impact of optimized SQL code on improving the performance and efficiency of database operations. It indirectly contributes to cost savings by reducing resource consumption. Here are some techniques that have proven invaluable in my experience: 1. Index Large Tables: Indexing tables with large datasets (>1,000,000 rows) greatly speeds up searches and enhances query performance. However, be cautious of over-indexing, as excessive indexes can degrade write operations. 2. Select Specific Fields: Choosing specific fields instead of using SELECT * reduces the amount of data transferred and processed, which improves speed and efficiency. 3. Replace Subqueries with Joins: Using joins instead of subqueries in the WHERE clause can improve performance. 4. Use UNION ALL Instead of UNION: UNION ALL is preferable over UNION because it does not involve the overhead of sorting and removing duplicates. 5. Optimize with WHERE Instead of HAVING: Filtering data with WHERE clauses before aggregation operations reduces the workload and speeds up query processing. 6. Utilize INNER JOIN Instead of WHERE for Joins: INNER JOINs help the query optimizer make better execution decisions than complex WHERE conditions. 7. Minimize Use of OR in Joins: Avoiding the OR operator in joins enhances performance by simplifying the conditions and potentially reducing the dataset earlier in the execution process. 8. Use Views: Creating views instead of results that can be accessed faster than recalculating the views each time they are needed. 9. Minimize the Number of Subqueries: Reducing the number of subqueries in your SQL statements can significantly enhance performance by decreasing the complexity of the query execution plan and reducing overhead. 10. Implement Partitioning: Partitioning large tables can improve query performance and manageability by logically dividing them into discrete segments. This allows SQL queries to process only the relevant portions of data. #SQL #DataOptimization #DatabaseManagement #PerformanceTuning #DataEngineering

Design of Experiments (DOE) is deeply entrenched in some R&D labs, and dismissed as overkill in others. A new paper shows you can use it both flexibly and frugally. DOE is widely used in ingredient screening, formulation development, process optimization, and beyond. The toolkit ranges from screening designs that separate active factors from noise, to factorial designs that quantify interactions, to response surface methods that model nonlinear behavior near an optimum. Each flavor makes a mathematically explicit tradeoff between resolution and experimental cost, suited to a different stage of development. In practice, I have seen teams pick a design without matching it to the question: full factorial "just to be safe" when a screening design would suffice. Further, even when the design type is right, it can often be further adjusted based on domain knowledge, for example weighting factors unequally or pooling dimensions known to matter less. The result is wasted effort and sometimes less clarity rather than more. A recent paper captures several practical DOE examples in catalyst screening and cross-coupling optimization that showcase flexible, frugal design shaped by both chemistry and instrumentation constraints. The authors reduced experiments by 75% compared to full factorial and still identified the most promising catalytic systems and conditions. Four lessons reinforced by this work: 🔹Start by ranking your variables: which factors drive outcomes, which interact, and which are secondary. That ranking is a bet. Making it explicit lets you invest experimental budget where it matters most and accept reduced coverage where a directional trend is sufficient. 🔹Match the design to that ranking. Some designs provide uniform coverage across all dimensions, ideal when factors are equally unknown. Others let you cut runs selectively on lower-impact dimensions. The right choice depends on what you must know precisely versus where a general trend is enough. 🔹Think in stages, not one big design. A preliminary screen does not need to find the optimum. It needs to eliminate dead ends and surface promising directions. Save the higher-resolution designs for the follow-up. It is being strategic to match the resolution and objective to each stage. 🔹Look beyond classical DOE when the problem calls for it. Approaches like Bayesian Optimization (BO) operate under different assumptions and yield different information. Understanding when each fits, and when to combine them, can unlock insights that no single method delivers alone. Check out the detailed use cases in the paper (including the integration of DOE and BO for cost-aware discovery), and see how you might adapt them to your own designs. 📄 Frugal Sampling Strategies for Navigating Complex Reaction Spaces, Organic Process Research & Development, April 10, 2026 🔗 https://lnkd.in/eQZjvzvc

Most brands analyze creative tests by looking at ROAS and CPA. That's like judging a restaurant by the bill instead of the food. ↳ Here's how to actually find winning patterns: Looking at performance metrics alone tells you IF something works. But it doesn't tell you WHY it works or how to replicate it. The Framework That Actually Works: 𝟭. 𝗦𝗽𝗹𝗶𝘁 𝗬𝗼𝘂𝗿 𝗠𝗲𝘁𝗿𝗶𝗰𝘀 𝗜𝗻𝘁𝗼 𝗧𝘄𝗼 𝗕𝘂𝗰𝗸𝗲𝘁𝘀 Primary metrics = Performance (tells you IF it works) - Spend, Purchases, CPA Secondary metrics = Storytelling (tells you WHY it works) - Scroll Stop Rate (hook strength) - Hold Rate (narrative engagement) - Outbound CTR (offer appeal) Why this matters: Performance metrics help you scale winners. Behavioral metrics help you create more winners. 𝟮. 𝗨𝘀𝗲 𝗕𝗲𝗵𝗮𝘃𝗶𝗼𝗿 𝘁𝗼 𝗙𝗶𝘅 𝗨𝗻𝗱𝗲𝗿𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗲𝗿𝘀 Don't change offers randomly. Let the data guide you: Low Scroll Stop Rate = Weak hook → Test bold claims, fast motion, pattern breaks Poor Hold Rate = Boring narrative → Improve pacing, cut slow parts Low Outbound CTR = Weak CTA/offer → Test different positioning Why this works: You're fixing the actual problem, not guessing at solutions. 𝟯. 𝗙𝗶𝗻𝗱 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀 𝗶𝗻 𝗬𝗼𝘂𝗿 𝗪𝗶𝗻𝗻𝗲𝗿𝘀 Stop looking at winning ads in isolation. Find common threads: Do they use specific hook styles? Similar pacing structures? Particular testimonial formats? Build a Creative Optimization Library documenting what works. Why this matters: Patterns create predictable processes. Processes eliminate guesswork. 𝟰. 𝗧𝗲𝘀𝘁 𝗪𝗶𝘁𝗵 𝗣𝘂𝗿𝗽𝗼𝘀𝗲 Most brands test random variations. Instead: If Scroll Stop Rate is bad → Test new hooks If Hold Rate is weak → Adjust storytelling If CTR is low → Optimize offer positioning Why this works: Every test has a clear objective and higher success probability. What You Can Expect: Fewer failed creative tests → Faster winner identification → Predictable creative production process → Higher overall ROAS from better optimization The Psychology: → Behavior data reveals true audience preferences. → Patterns show what actually drives action. → Purpose-driven testing eliminates waste. Next Steps: Week 1: Set up behavioral metric tracking Week 2: Analyze your last 10 winners for patterns Week 3: Build your Creative Optimization Library Week 4: Implement purpose-driven testing Be honest... Are you iterating creatives based on data, or gut instinct?

2026-𝐫𝐞𝐚𝐝𝐲 𝐋𝐋𝐌 𝐎𝐩𝐭𝐢𝐦𝐢𝐳𝐚𝐭𝐢𝐨𝐧 𝐆𝐮𝐢𝐝𝐞 𝐭𝐨 𝐡𝐞𝐥𝐩 𝐲𝐨𝐮 𝐟𝐢𝐱 𝐭𝐡𝐚𝐭 𝐛𝐞𝐟𝐨𝐫𝐞 𝐢𝐭 𝐛𝐫𝐞𝐚𝐤𝐬 𝐲𝐨𝐮𝐫 𝐛𝐮𝐝𝐠𝐞𝐭 (𝐚𝐧𝐝 𝐲𝐨𝐮𝐫 𝐩𝐫𝐨𝐝𝐮𝐜𝐭 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞). → 1. 𝐏𝐫𝐨𝐦𝐩𝐭 𝐂𝐨𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 • Cut redundant instructions to reduce tokens. • Use structured formats like JSON. • Keep system messages minimal. → 2. 𝐌𝐨𝐝𝐞𝐥 𝐑𝐢𝐠𝐡𝐭-𝐒𝐢𝐳𝐢𝐧𝐠 • Use small/medium models for 70% of queries. • Cascade to larger models only when needed. • Track cost per request. → 3. 𝐑𝐀𝐆 𝐟𝐨𝐫 𝐒𝐦𝐚𝐫𝐭𝐞𝐫 𝐂𝐨𝐧𝐭𝐞𝐱𝐭 • Retrieve only relevant chunks. • Keep embeddings fresh and consistent. • Reduce hallucinations without scaling model size. → 4. 𝐅𝐢𝐧𝐞-𝐓𝐮𝐧𝐢𝐧𝐠 𝐖𝐢𝐭𝐡 𝐏𝐫𝐞𝐜𝐢𝐬𝐢𝐨𝐧 • Use small, high-quality datasets. • Validate with behavioral test cases. • Remove noisy or inconsistent samples. → 5. 𝐂𝐚𝐜𝐡𝐞 𝐄𝐯𝐞𝐫𝐲𝐭𝐡𝐢𝐧𝐠 𝐏𝐨𝐬𝐬𝐢𝐛𝐥𝐞 • Cache embeddings and frequent responses. • Reuse validated outputs to save compute. • Reduce latency in high-traffic loops. → 6. 𝐏𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧-𝐋𝐞𝐯𝐞𝐥 𝐏𝐫𝐨𝐟𝐢𝐥𝐢𝐧𝐠 • Test on real traffic, not lab prompts. • Monitor latency and error spikes. • Track token patterns weekly. → 7. 𝐎𝐩𝐭𝐢𝐦𝐢𝐳𝐞 𝐑𝐞𝐭𝐫𝐢𝐞𝐯𝐚𝐥 𝐏𝐢𝐩𝐞𝐥𝐢𝐧𝐞 • Tune chunk sizes for clarity. • Use hybrid search when needed. • Improve ranking with metadata signals. → 8. 𝐈𝐦𝐩𝐫𝐨𝐯𝐞 𝐈𝐧𝐩𝐮𝐭 𝐕𝐚𝐥𝐢𝐝𝐚𝐭𝐢𝐨𝐧 • Filter incomplete or low-quality queries. • Add guardrails before calling the model. • Standardize user prompts. → 9. 𝐑𝐞𝐝𝐮𝐜𝐞 𝐎𝐯𝐞𝐫-𝐆𝐞𝐧𝐞𝐫𝐚𝐭𝐢𝐨𝐧 • Control max tokens. • Enforce tight output formats. • Avoid unnecessary elaboration. → 10. 𝐂𝐨𝐧𝐭𝐢𝐧𝐮𝐨𝐮𝐬 𝐌𝐨𝐧𝐢𝐭𝐨𝐫𝐢𝐧𝐠 • Watch for accuracy drift. • Track model downtime. • Refresh data and prompts regularly. follow Devjyoti Seal for more insights

Capacity Optimization (Optimization Part-5) Efficient PRB (Physical Resource Block) usage is crucial for improving DL user throughput. High PRB utilization can lead to network congestion and degraded performance, especially in areas with high traffic demand. Here's a breakdown: High Utilization Challenges (example): Carrier 1 - 800 MHz: •13% of samples show PRB utilization > 70%, resulting in DL user throughput < 4 Mbps. Carrier 2 - 1800 MHz: •7% of samples show PRB utilization > 90%, with DL user throughput < 4 Mbps. Ways to Cater to High Utilization: 1. Channel Optimization: Optimize channel allocation and resource scheduling to improve PRB efficiency. 2. Add New Sectors in Sites / Load Balance: New sectors can help distribute traffic evenly across the network, reducing congestion and improving throughput. 3. Enhance Antenna Technology: Leverage advanced antenna tech (e.g., MIMO) for better signal distribution and capacity handling. 4. Add New Sites / Carrier / Spectrum Refarming: Deploy additional sites to expand coverage and capacity. Implement spectrum refarming to repurpose underutilized frequency bands for more efficient resource use. Key Takeaways: • High PRB utilization is directly linked to poor DL throughput, especially in congested areas. • Capacity optimization strategies, including channel optimization, sector addition, and spectrum management, are key to enhancing network performance and user experience. By applying these strategies, operators can reduce congestion, improve DL throughput, and better cater to high utilization areas, ensuring optimal network performance. To learn more, refer to the course on RAN Engineering - https://lnkd.in/e9TpSHzF

Mastering Spark Optimization: A Data Engineer’s Edge Working with Apache Spark is powerful — but without the right optimizations, even the best clusters can struggle. Over the years, I’ve realized that Spark optimization is not just about cutting costs, but about unlocking real performance and scalability. Here are some key Spark optimization techniques every data engineer should keep in their toolkit: 🔹 1. Optimize Data Formats Use columnar formats like Parquet or ORC instead of CSV/JSON. They reduce storage size and speed up queries significantly. 🔹 2. Partitioning & Bucketing Partition data wisely on frequently used keys. Use bucketing for joins on large datasets to avoid costly shuffles. 🔹 3. Caching & Persistence Cache intermediate results when reused across stages, but be mindful of memory overhead. 🔹 4. Broadcast Joins For small lookup tables, use broadcast joins to avoid shuffle-heavy operations. 🔹 5. Shuffle Optimization Minimize wide transformations. Use reduceByKey instead of groupByKey to cut down on shuffle size. 🔹 6. Adaptive Query Execution (AQE) Enable AQE in Spark 3+ to dynamically optimize joins and shuffle partitions at runtime. 🔹 7. Resource Tuning Right-size executors, cores, and memory. More is not always better — balance matters. 🔹 8. Avoid UDF Overuse Use Spark SQL functions where possible. Built-in functions are optimized at the Catalyst level, while UDFs can be a performance bottleneck. ✨ The real game-changer: Optimization is not one-size-fits-all. Profiling your jobs and understanding data characteristics is the key. 👉 What’s your go-to Spark optimization technique that saved you the most time (or cost)? #ApacheSpark #DataEngineering #BigData #Optimization #PerformanceTuning

How Optimization Algorithms Work – Explained Simply 🔹 Heuristics: Fast & Practical A heuristic is a rule of thumb for decision-making. It doesn’t guarantee the best solution, but it’s often good enough. A strong heuristic has at least one of these qualities: ✅ It finds high-quality solutions quickly. ✅ It delivers decent results with minimal effort. Even if a heuristic fails often, it can still be valuable if it's computationally cheap to try again. 🔹 Local Optimization: Climbing the Wrong Hill Imagine climbing a mountain. You always take steps that increase your altitude. If a step doesn’t go up, you try another direction. Eventually, you’ll reach a peak. Unless there is only one peak, it may not be the highest one. That’s local optimization: great at fine-tuning solutions but often stuck in local optima. Fun fact: Mathematician Gunter Dueck once made a sign error in his algorithm. Instead of always stepping upward, his method allowed tiny downward steps. The result? A world record in solving Traveling Salesman Problems—and a new IBM research department built on this mistake. 🔹 Constraint Programming: Solving Sudoku with Pencil & Rubber Solving a Sudoku puzzle with a pencil and rubber is a great analogy for constraint programming. Imagine a 3×3 box where you need to place the numbers 1, 2, and 3. You start by writing a 1 in the first available cell. Now, only the 2 and 3 remain. You pencil in the 2 in one of the two remaining spots. Then, you check whether the 3 fits in the last empty cell. If it works, great! If not, you erase the 2 and try placing it in the other spot. Still no luck? Then even the 1 was wrong, so you erase that too and start again with a different choice. Constraint programming works the same way: it systematically tries values, corrects mistakes, and efficiently finds valid solutions—just like a Sudoku solver with a good pencil and a well-used rubber. 🔹 Global Optimization: Finding the Highest Peak Efficiently If I wanted to climb Germany’s highest mountain, I wouldn’t start hiking in Münsterland. I’d first take a train to the Alps—there’s no point searching for mountains in flatland. Once in the Alps, I’d only hike on clear days when I can see for kilometers. If I spot a higher peak, I’ll climb it. If there are no taller mountains in sight, I’ll note my altitude and move to a different region. And on cloudy days? I’d relax in the hotel and enjoy Bavarian cuisine. 😉 This is how global optimization works. Instead of blindly searching everywhere, it rules out entire areas (like Münsterland) where the best solution can’t be. Then, it focuses computational effort on the most promising regions—just like hiking only on clear days for maximum visibility. 🔎 Want to optimize your planning, scheduling, or resource allocation? Let’s talk! I help businesses streamline their decision-making using smart optimization techniques. Drop me a message! 🚀

Optimization under uncertainty without stochastic optimization A friend of mine (former colleague from Princeton) and a top optimization specialist emailed me recently:   “If I have a way to quantify uncertainty from my data, how do I incorporate that uncertainty into the decision making process? (This is where stochastic programming, approximate dynamic programming, and a host of other techniques come into play).”   The idea that you have to use “stochastic programming” or “approximate dynamic programming” to handle uncertainty in optimization is simply wrong. These are tools that are popular in the academic journals, but rarely used in practice.   A far more powerful approach is to begin by thinking about how uncertainty would affect the solution to the problem, and introduce parametric adjustments, either to the objective function or (more often) to the constraints.   The first step is to recognize that the optimization problem being solved at a point in time is a surrogate – solving it is a policy for solving a sequential decision problem (as I illustrate in the graphic below).   There are two challenges getting this model to work well over time:   o You have to decide how to parameterize the model to make it work well over time. o Then, you have to tune the parameters, either in a simulator or by watching how it works in the field.   The simulator is your model, not the optimization model that produces the decision. This is where stochastic processes are represented. The tuning picks up the effects of uncertainty as the policy is simulated, avoiding the complexity of introducing uncertainty explicitly in the policy.   And remember – an optimal solution to the surrogate model is not an optimal policy… but if carefully designed, it might be quite good.   I call this approach a parametric cost function approximation (CFA). An illustration is provided on the webpage:   https://lnkd.in/dmh36K-c (“tinyurl.com/” with “cfapolicy”)   Or go to chapter 13 of my RLSO book:   https://lnkd.in/dB99tHtM (“tinyurl.com/” with “RLandSO”)   You can download chapter 13 from https://lnkd.in/eWTMDURh.