<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Peculiar Robbins on Medium]]></title>
        <description><![CDATA[Stories by Peculiar Robbins on Medium]]></description>
        <link>https://medium.com/@peculiargold?source=rss-c63b7de8a9bb------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*FtWtDsfodSEWgDsZ.jpg</url>
            <title>Stories by Peculiar Robbins on Medium</title>
            <link>https://medium.com/@peculiargold?source=rss-c63b7de8a9bb------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 12:15:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@peculiargold/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[I Thought "groupby" Was Easy. Then UK Milk Humbled Me.]]></title>
            <link>https://medium.com/@peculiargold/i-thought-groupby-was-easy-then-uk-milk-humbled-me-0d080f8322d8?source=rss-c63b7de8a9bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/0d080f8322d8</guid>
            <dc:creator><![CDATA[Peculiar Robbins]]></dc:creator>
            <pubDate>Sat, 31 Oct 2026 22:37:31 GMT</pubDate>
            <atom:updated>2026-10-31T22:37:31.559Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Week 8 of my DataraFlow data analytics internship: the day a few rows of A, B and C turned into a story about a country’s economy</em>.</p><h3>How five months of dairy trade data taught me to think in groups, distrust my own totals, and love a good NaN</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZrwsZMfBd4c4efsPj-h-dg.png" /><figcaption>Milk, Money &amp; Confusion</figcaption></figure><p>I&#39;ll be honest: when I saw that this week&#39;s project was about milk, I almost laughed.<br>Milk? After weeks of Python, pandas and SQL, I was handed the UK&#39;s dairy trade for 2015 and asked four innocent-looking questions. I was sure it would take an evening.<br>It took me a lot longer than that. And somewhere between my first groupby and my last window function, I stopped learning syntax and started learning how to think.<br>This is the story of that week: what clicked, what broke, and the one mistake that nearly made every number I produced a lie.</p><h4>The mission: four questions about milk</h4><p>The data came from the United Nations Comtrade database: the UK’s monthly imports and exports of milk and cream, January to May 2015, with every partner country listed. Two commodity codes: 0401 (unprocessed) and 0402 (processed). My job was to answer:<br>1. How much does the UK import and export, and is the balance positive?<br>2. Who are the main trading partners?<br>3. Which countries buy milk from the UK every single month?<br>4. Which countries does the UK both buy from and sell to?</p><p>Four questions, four ways of thinking</p><p>Four questions. Four different tools. That diagram is the map I wish someone had handed me on day one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6gEVJ7DyxGG1q0oNPklyFQ.png" /><figcaption>Four questions, four ways of thinking</figcaption></figure><h4>Confusion #1: the zero that vanished</h4><p>Before any analysis, my first &quot;wait, what?&quot; arrived at the loading stage.<br>The commodity codes are 0401 and 0402. If pandas decides they’re numbers, they quietly become 401 and 402. The leading zero disappears, and my function that turns codes into &#39;unprocessed&#39; and &#39;processed&#39; would return &#39;unknown&#39; for every single row.<br>Nothing crashes. No error. Just a column full of &quot;unknown&quot; and a slowly sinking feeling.<br>Lesson: codes that look like numbers are often labels. Read them as strings.</p><h4>The idea that changed everything: Split, Apply, Combine</h4><p>Everything this week hangs on one mental model, and it took me a while to truly see it.<br>Every groupby is the same three-step dance:</p><ol><li>Split the big table into smaller groups.</li><li>Apply a calculation (sum, count, filter) to each group.</li><li>Combine the results back into one tidy table.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_JiBjNBdwB3tIGBczM0O3Q.png" /><figcaption>Split, Apply, Combine</figcaption></figure><p>Once I saw it this way, groupby stopped being a magic spell and became a recipe. Question 1 was just this:</p><h4>grouped = milk.groupby([FLOW])<br>grouped[VALUE].aggregate(sum)</h4><p>Split by Imports/Exports, sum each group, combine. The answer: a trade surplus of over 100 million US dollars. The UK sold far more milk than it bought. Small code, big insight, and my first real &quot;oh!&quot; moment of the week.</p><h4>The trap: when my numbers were secretly doubled</h4><p>This is the part I most want you to remember.<br>The dataset contains rows where the partner is literally called `’World’`. These are the monthly totals for each flow. They’re helpful as a summary, but they are poison for a groupby.<br>If you leave them in, every country’s trade is counted once as itself and once again inside &quot;World.&quot; Your totals are silently doubled, and nothing warns you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o-njIbzXX0xSm06UwpVYjw.png" /><figcaption>The World trap</figcaption></figure><p>The fix is one line:</p><h4>milk = milk[milk[PARTNER] != &#39;World’]</h4><p>What scared me wasn’t the bug. It was how reasonable the wrong answer looked. A doubled total is still a believable number.</p><blockquote>Lesson: before you aggregate, ask what each row actually represents. A total sitting next to its own parts is a classic way for an analysis to lie to you.</blockquote><h4>Question 2: who are our main partners?</h4><p>Now the groups were by country, separately for imports and exports, sorted from biggest to smallest:</p><h4>imports = milk[milk[FLOW] == &#39;Imports’]<br>grouped = imports.groupby([PARTNER])<br>totalImports = grouped[VALUE].aggregate(sum).sort_values(ascending=False)<br>totalImports.head(10).plot(kind=’barh’)</h4><p>The picture was striking:</p><ul><li>The UK exported to over 100 countries, but imported from only 21.</li><li>The biggest import sources were all geographically close. Milk is perishable, so proximity matters.</li><li>Ireland emerged as the main partner, but it bought almost three times more from the UK than it sold to the UK.</li></ul><p>Seeing data become a story like this was when it stopped feeling like homework.</p><h4>Question 3: the question that melted my brain</h4><p>&quot;Which countries buy milk from the UK every month?&quot;<br>I stared at this for a long time. How do you filter by a property of a whole group, not of a single row?<br>Then came the definition that unlocked it. A &quot;regular customer&quot; buys both commodities in all five months. That’s 2 × 5 = 10 rows per country. So a regular customer is simply a group with exactly ten rows:</p><h4>def buysEveryMonth(group):<br> return len(group) == 10<br> <br>regular = exports.groupby([PARTNER]).filter(buysEveryMonth)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lcG2YJLXna-O1P-qUAcDaA.png" /><figcaption>What does a regular customer look like?</figcaption></figure><p>That’s filter on a group: instead of asking &quot;is this row good enough?&quot;, I was asking &quot;is this whole group good enough?&quot; It felt like discovering a new gear.<br>The payoff: 16 countries passed the test, and they generate roughly 75% of all UK milk export value. A handful of loyal customers carry the whole business.</p><h4>Question 4: the quiet power of NaN</h4><p>For the final question I met pivot_table, which turns a long list into a clean grid, with one row per country and one column per trade flow:</p><h4>countries = pivot_table(milk, index=[PARTNER], columns=[FLOW],<br> values=VALUE, aggfunc=sum)<br>countries.dropna()</h4><p>If a country only buys from the UK (or only sells to it), the missing side shows up as NaN. I used to treat NaN as an annoyance. Here, the missing value was the answer. dropna() kept only the countries with trade flowing in both directions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RFBHPA9EE4V39niYEv2Gvw.png" /><figcaption>Pivot tables and the bidirectional trade overlap</figcaption></figure><p>The result: 20 countries trade both ways with the UK. But a few of them had suspiciously tiny trade values, which made me wonder whether the data itself was trustworthy. That was a real lesson: finding a number isn’t the same as believing it.</p><h4>Plot twist: doing it all again in SQL</h4><p>Then came the section that humbled me most. The same questions, but in SQL.<br>GROUP BY is split-apply-combine in different clothes. But the practice tasks went further:</p><ul><li>Conditional aggregation (SUM(CASE WHEN ... THEN ... END)) to build a monthly imports-vs-exports table, which is the SQL twin of pivot_table.</li><li>`GROUPING SETS` to produce quarterly numbers with year subtotals in a single query.</li><li>Window functions to rank the top 3 partners inside each trade flow.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rcpaNgCBRablMi7ssoWVDg.png" /><figcaption>Window functions rank inside each group</figcaption></figure><p>Window functions were my steepest climb. The mental shift is that GROUP BY collapses rows, while OVER (PARTITION BY ...) lets you keep every row and still calculate across its group. And the gotcha that bit me: you can’t filter on a window function in the same `WHERE`. You need a CTE, so you calculate the rank first and filter in the outer query.<br>I’d like to say I got it first time. I didn’t. That error message and I became very well acquainted.</p><h4>What I’d tell my past self</h4><p>1. Ask &quot;what does one row mean?&quot; before every aggregation. The &#39;World&#39; rows taught me this the hard way.<br>2. Think in groups, not loops. If you’re about to write a for loop over rows, there’s probably a groupby waiting.<br>3. Sanity-check every result against reality. Does the surplus make sense? Are the biggest partners nearby? A surprising number is either a discovery or a bug, and you have to find out which.<br>4. Learn the idea once, then see it everywhere. Split-apply-combine lives in pandas, in SQL and in every dashboard you’ll ever build. The syntax changes; the thinking doesn’t.<br>5. Don’t hide your confusion. Every &quot;I don’t get it&quot; this week turned into the clearest lesson, precisely because I had to fight for it.</p><h4>What I found, in one breath</h4><p>Between January and May 2015, the UK ran a milk and cream trade surplus of over $100 million. It exported to 100+ countries but imported from just 21. Sixteen loyal customers account for around three quarters of export value. And 20 countries trade both ways with the UK, though some of those numbers deserve a raised eyebrow.<br>Not bad for something I almost laughed at.</p><h4>Your turn</h4><p>If you’re learning pandas or SQL right now and a dataset feels too boring or too simple, pick it anyway. The most ordinary data (milk, of all things) hides the sharpest lessons, as long as you’re willing to ask the right questions and doubt your first answer.<br>Next up: I’ll repeat this analysis with data I download myself from Comtrade, plus the seaborn visualisations I’ve been itching to build. If you’d like to follow along, hit follow. And tell me in the comments: what was the first bug that truly humbled you?<br>Thanks for reading. If this helped even one `groupby` click for you, a clap would make my week. 🥛</p><p>#Data Science #Python #Pandas #SQL #Data Analysis</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0d080f8322d8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Nobody Told Me Data Science Is Mostly Plumbing]]></title>
            <link>https://medium.com/@peculiargold/nobody-told-me-data-science-is-mostly-plumbing-c02a5ebaef0e?source=rss-c63b7de8a9bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/c02a5ebaef0e</guid>
            <dc:creator><![CDATA[Peculiar Robbins]]></dc:creator>
            <pubDate>Mon, 19 Oct 2026 23:41:05 GMT</pubDate>
            <atom:updated>2026-10-19T23:41:07.049Z</atom:updated>
            <content:encoded><![CDATA[<p>Week 1 DATARAFLOW COHORT 2 JOURNEY</p><h4>I started week one expecting neural networks. I left it with a different question, and a better one.<br>Week 1 field notes · 6 min read</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*4xlDTRAromvgFKdwBcT04g.jpeg" /></figure><p>What data science looks like from outside, and from inside.<br>On Monday I installed everything. Python, a notebook environment, a couple of libraries I couldn’t yet explain. By Tuesday I’d watched a video that quietly demolished the picture in my head.</p><blockquote>The picture was this: data scientists are people in dark rooms training models that recognize cats, drive cars, and write poems. The video’s version was less cinematic. Data science is using data to produce insight that helps a business make a better decision. That’s the job. The model is occasionally a tool for it. Often it isn’t even needed.</blockquote><h3>A perfect model that answers the wrong question is worth less than a boring chart that answers the right one.</h3><p>I read that sentence three times, because I had spent the weekend before bookmarking deep learning courses.</p><h4>The idea that reorganized my whole plan</h4><p>The framework that did the most damage (in a good way) is the Data Science Hierarchy of Needs, usually credited to data scientist Monica Rogati. Think Maslow, but for data. You can’t self-actualize with a neural net if nobody has collected the data, stored it somewhere sane, and checked that it isn’t garbage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*U3KKHTi3f8dDnaeeQJZ2lA.jpeg" /></figure><p>A simplified take on the hierarchy. Most of the width, and most of the work, lives at the bottom.<br>This explained something that had confused me. Job descriptions for “data scientist” range from “build our recommendation engine” to “own our weekly KPI report.” Both are legitimate. The hierarchy tells you why: the role stretches or shrinks depending on the company.</p><h4>Startup vs. big company: same title, different life</h4><p>At a small startup, nobody else exists to hand things to. The data scientist ends up wearing every hat: setting up logging, building the pipeline, cleaning, analyzing, sometimes modeling. At a larger company, the work splits into specialties, and a typical data scientist spends most of their time on analytics, metrics, and preparing data, with machine learning as a slice rather than the whole pie.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*ROVvIz4I0HALtM-JlXAsOQ.jpeg" /></figure><p>Here’s the part that stung. The version of data science that gets the headlines (self-driving cars, generative AI) is real, but it’s mostly the territory of specialized AI researchers. The average working data scientist spends their days on something quieter: understanding data, building trustworthy metrics, and making sure the business can actually decide things.<br>I used to hear “boring” as an insult. Now I read it as job security. The boring middle is what keeps companies running.</p><h4>What I’m changing about how I learn</h4><p>Before this week, my plan was a list of tools. Now my plan starts with a question: what problem is this for? If I’d kept the old plan, I would have sprinted to algorithms and skipped the layers underneath them, which is a bit like painting the roof of a house with no walls yet.</p><h3>Here are the seven rules I’m actually holding myself to:</h3><ol><li>Learn the why before the how. Tools churn every year. Problems repeat. If I know the problem, a new tool is just a familiar problem in a different outfit.</li><li>Attach every concept to a business question. “How would this help a company understand its customers?” Ideas stick when they have somewhere to land.</li><li>Don’t skip levels. Cleaning, structuring, and exploring data comes before modeling. Unglamorous, yes. It’s also where the hours go.</li><li>Build small, finished projects. Watching tutorials feels like progress. The real test: can I take a messy dataset and produce one clear insight, alone, start to finish?</li><li>Sit with the confusion. Not knowing the right method, or the right question, is part of the work. Jumping to the first shortcut tutorial is how I stay shallow.</li><li>Keep a “didn’t click” list. Revisit it a week later. Things that were fog on Tuesday are often obvious by the next Tuesday.</li><li>Separate interesting from important. AI is fascinating, and I’ll get there. But wrangling, analysis, and explaining findings clearly will be most of my day, so they get my first months.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*Vt57R-lv9YEQMiCMVovERQ.jpeg" /></figure><h4>The question I’m carrying into week two</h4><p>I started the week asking, “Which tools do I need to learn?” I’m ending it asking, “What problem am I trying to solve, and what does the data say about it?”<br>It’s a smaller question on the surface. It’s a much bigger one underneath. And it turns out to be the one every level of that pyramid is quietly answering.</p><h3>If you’re starting out too, tell me: what’s the one belief about data science you had to unlearn first? I’m collecting them.</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c02a5ebaef0e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I ALMOST QUIT DATA ANALYSIS AT DAYS/WEEKS. THEN SQL, PANDAS AND NUMPY FINALLY CLICKED]]></title>
            <link>https://medium.com/@peculiargold/i-almost-quit-data-analysis-at-days-weeks-then-sql-pandas-and-numpy-finally-clicked-8b098d92936d?source=rss-c63b7de8a9bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b098d92936d</guid>
            <dc:creator><![CDATA[Peculiar Robbins]]></dc:creator>
            <pubDate>Mon, 19 Oct 2026 15:51:11 GMT</pubDate>
            <atom:updated>2026-10-19T16:30:49.135Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>*Three tools, one pipeline, and the honest story of the confusion in between.*</strong></h3><p>Week 6 DataraFlow Cohort 2 Journey</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yo8GZGjN5edgkSYsZcWURw.png" /></figure><h4>A pipeline view of three tools that felt like three mountains, plus the real challenges of learning them together.</h4><p>When I was told I would learn SQL, Pandas and NumPy in the same stretch of weeks, I assumed I was being handed three separate subjects. By the end, I understood the truth: they are one workflow. Each tool answers a different part of the same question.<br>The question is always some version of this: What is the data actually telling us?</p><h3>On 13th October 2026 , I stared at an error message I couldn’t read, closed my laptop, and thinking what i actually did or thought. &quot;I told myself I wasn’t built for data&quot;</h3><p>I hadn’t failed an exam. Nothing dramatic had happened. I was simply learning SQL, Pandas and NumPy in the same stretch of weeks, and none of it was connecting.</p><p>I’m still learning. But I now understand why I nearly quit, and what turned the confusion into direction. you’re a beginner who is lost right now, this is for you.</p><h4>The Question Behind Every Tool</h4><blockquote>Every data project starts with a question, such as: *Which regions drive our revenue, and are they growing or just noisy?*</blockquote><blockquote>The answer sits in a database with thousands or millions of rows. Getting to it takes three tools:</blockquote><h4>| Stage | Tool | Job |<br>1. | Retrieve | **SQL** | Pull only the data you need from the database |<br>2. | Analyse | **Pandas** | Clean, shape and explore it as a table |<br>3. | Compute | **NumPy** | Run fast numerical operations underneath |</h4><blockquote>That table is the most useful thing I learned. But I didn&#39;t see it at first. I treated these as three separate subjects, and that was my first mistake.</blockquote><h4>Stage 1: SQL, Learning What to Leave Behind</h4><p>SQL is how you talk to a database. The skill isn&#39;t writing long queries. It&#39;s deciding what *not* to bring back.</p><blockquote>```sql<br>SELECT region,<br> COUNT(*) AS total_orders,<br> SUM(amount) AS revenue<br>FROM orders<br>WHERE order_date &gt;= &#39;2026-01-01&#39;<br>GROUP BY region<br>HAVING SUM(amount) &gt; 100000<br>ORDER BY revenue DESC;<br>```</blockquote><h4>In plain English: take this year&#39;s orders, group them by region, total them, keep only the big regions, and rank them.</h4><h4>Where I got stuck:** I kept filtering totals with `WHERE`:</h4><p>```sql<br>WHERE SUM(amount) &gt; 100000<br>-- ERROR: aggregate functions are not allowed in WHERE<br>```</p><h4>`WHERE` filters *rows before* grouping. `HAVING` filters *groups after* aggregation. Once that clicked, a whole category of my errors disappeared. **[Add your own version: the exact query that failed and how you felt.]**</h4><h4>Stage 2: Pandas, Turning Results into Something Explorable</h4><blockquote>Pandas gives you a DataFrame, a table you can inspect and reshape inside Python.</blockquote><p>```python<br>import pandas as pd<br>from sqlalchemy import create_engine</p><p>engine = create_engine(&quot;postgresql+psycopg2://user:password@host:5432/shop&quot;)</p><p>query = &quot;&quot;&quot;<br>SELECT region, COUNT(*) AS total_orders, SUM(amount) AS revenue<br>FROM orders<br>WHERE order_date &gt;= &#39;2026-01-01&#39;<br>GROUP BY region<br>&quot;&quot;&quot;</p><p>df = pd.read_sql(query, engine)</p><p>df.info()<br>df.describe()<br>top = df[df[&quot;revenue&quot;] &gt; 100_000].sort_values(&quot;revenue&quot;, ascending=False)<br>df[&quot;avg_order_value&quot;] = df[&quot;revenue&quot;] / df[&quot;total_orders&quot;]<br>```</p><h4>Where I got stuck:** The connection. Before any analysis, I had to get the host, port, credentials and driver right. A wrong detail produces an error that means almost nothing to a beginner:</h4><p>```<br>psycopg2.OperationalError: connection to server at &quot;...&quot; failed<br>```</p><h3>When it finally worked, it felt small to everyone else and enormous to me. **[Add your moment: how long it took, what the fix was, how it felt.]**</h3><h4>Stage 3: NumPy, Thinking in Whole Arrays</h4><blockquote>Every Pandas column sits on top of a NumPy array. NumPy&#39;s strength is **vectorisation**: operating on an entire array at once instead of looping.</blockquote><p>```python<br>import numpy as np</p><p>revenue = df[&quot;revenue&quot;].to_numpy()<br>shares = revenue / revenue.sum() # no loop needed</p><p>np.mean(revenue)<br>np.median(revenue)<br>np.std(revenue)<br>np.percentile(revenue, [25, 50, 75])<br>```</p><h4>Where I got stuck:** Array dimensions felt theoretical until this error appeared:</h4><p>```python<br>np.array([1, 2, 3]) + np.array([1, 2])<br># ValueError: operands could not be broadcast together<br>```</p><h3>Only after fighting errors like that did &quot;shape&quot; become a real idea instead of a vocabulary word.</h3><h4>The Challenges, Honestly I Experienced While Learning</h4><h4>The tools were not the hardest part. Learning them under pressure was.<br>1. Getting connected to the database.</h4><p>Before a single query could run, I had to get the connection details, credentials and setup right. A wrong host, port or password fails with an error that tells a beginner almost nothing. It looks like a small step, but everything depends on it. Getting it to work was my first real win.</p><h4>2.Knowing a keyword versus knowing when to use it.</h4><blockquote>I could define `JOIN`, `CASE`, `UNION` and `CTE`. Choosing the right one for a real question was a different skill.</blockquote><h4>3. Wrong answers that look right.</h4><p>A query that errors is helpful. A query that runs and returns the wrong numbers is dangerous.</p><h4>4. Too many ways to do one thing in Pandas.</h4><p>I never knew which was cleanest or safest, and I hit warnings about modifying copies of data. Using `.loc` helped.</p><h4>5. Cryptic error messages.</h4><p>They felt like punishment until I learned to read them as clues.</p><h4>6. Time pressure.</h4><p>Deadlines arrived before my understanding did. Real learning means mistakes, rereading and trying again, which doesn’t fit a tight schedule.</p><h4>7. Mixing up WHERE and HAVING.</h4><p>I made this mistake more than once. The query either errored or quietly returned the wrong numbers, which is worse, because wrong answers still look like answers.</p><h4>8. NumPy’s abstract concepts and shape errors.</h4><p>Arrays with zero, one, two or three dimensions felt theoretical until my code failed:</p><p>Python</p><p>np.array([1, 2, 3]) + np.array([1, 2])<br># ValueError: operands could not be broadcast together</p><h4>9. Pandas&#39; many ways to do the same thing.</h4><blockquote>Selecting columns, filtering rows and chaining operations can each be written several ways. As a beginner, I couldn’t tell which was cleanest or safest, and I ran into warnings about modifying copies of data. Using .loc for selecting and assigning helped.</blockquote><h4>8. Comparison.</h4><blockquote>Watching others move quickly made me doubt my own pace.</blockquote><h4>The Moment I Almost Quit</h4><h3>It wasn’t one dramatic failure. It was an accumulation: It was 11 p.m. My query had failed for the Tenth time, Portal keeps reopening for my submission I almost, I keep sending in messages for assistance. Still not getting it right.</h3><ul><li>A database connection that refused to work, with an error message that told me almost nothing</li><li>A query that ran without errors but returned numbers I couldn’t trust</li><li>A NumPy error about shapes that looked like it was written in another language</li><li>Deadlines that kept arriving before my understanding did<br>Late one evening,</li></ul><p>I thought: &quot;Everyone else seems to get this. Maybe I’m just not a data person.&quot;<br>That thought is the real danger for beginners. It is not the difficulty of the material. It is the story we tell ourselves about the difficulty.</p><h4>What Finally Made It Click</h4><p>The turning point was not a better tutorial. It was a shift in perspective. I stopped asking, &quot;What does this keyword do?&quot; and started asking, &quot;Which stage of the process am I in?&quot;</p><p>For me, the shift was seeing the pipeline. There weren’t three mountains. There was one path with three stages(SQL, then Pandas, then NumPy).</p><h4>What Kept Me Going</h4><ul><li>Practising the whole pipeline. I stopped studying tools in isolation and ran one question through all three stages(SQL, then Pandas, then NumPy) .</li><li>Writing the question in plain English first. Code came second.</li><li>Reading errors slowly. The message almost always names the problem.</li><li>Revisiting weak topics on purpose. Slowing down was not falling behind.</li><li>Celebrating small wins. A working connection counted.<br>Remembering confusion is part of learning. It was never a verdict on my ability.</li></ul><h4>Mistakes Worth Avoiding</h4><h3>1. `SELECT *` on large tables. Name the columns you need.<br>2. Aggregating millions of rows in Pandas when SQL can do it faster.<br>3. Looping over DataFrame rows when a vectorised operation exists.<br>4. Memorising syntax without understanding the purpose.</h3><h4>If You’re Where I Was</h4><ul><li>You are not slow. You are learning three tools at once.</li><li>Understanding arrives *after* repetition, not before it.</li><li>Every analyst you admire once stared at an error they couldn’t read.</li><li>Quitting feels logical at your lowest point and looks like a mistake from the other side.</li></ul><h4>Where I Am Now</h4><h3>I haven’t mastered SQL, Pandas or NumPy. But I know what each one is *for*, and I can move a question through all three stages, even if slowly.</h3><h3>Confusion didn&#39;t mean I should stop. It meant I was in the middle of becoming capable.</h3><h3>If you&#39;re close to giving up, stay one more week. Then one more.</h3><p>*Tags: #SQL #Pandas #NumPy #Data Analysis #Python*</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b098d92936d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Before I Built an AI for Construction, I Had to Understand the Problem]]></title>
            <link>https://medium.com/@peculiargold/before-i-built-an-ai-for-construction-i-had-to-understand-the-problem-bc5369a25849?source=rss-c63b7de8a9bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc5369a25849</guid>
            <dc:creator><![CDATA[Peculiar Robbins]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 04:28:54 GMT</pubDate>
            <atom:updated>2026-10-14T07:39:47.018Z</atom:updated>
            <content:encoded><![CDATA[<p>Before I Built an AI for Construction, I Had to Understand the Problem</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/1*XZbMJiV0jqDF_Q6KZSHNWw.png" /></figure><p>How a delayed duplex renovation shaped BuildSmart360, a research project on explainable delay-risk prediction</p><p>A week before handover, the client asked one question: &quot;Why is the project still not finished?&quot;*</p><p>The site looked busy. Workers were present. Materials had arrived. The contractor insisted everything was under control.</p><p>Yet the completion date kept moving.</p><p>No single report explained why. The schedule said one thing and the procurement record said another. Labour availability, weather disruption, rework and cost changes lived in separate files, messages and people&#39;s heads.</p><p>That renovation taught me something I have not stopped thinking about:</p><p>Construction projects rarely fail because of one large problem. They fail because small problems stay invisible until they become expensive.</p><p>It became the starting point for my DataraFlow Cohort 2 research project: **BuildSmart360, an AI-Powered Construction Project Monitoring and Decision Support System.** The study examines how artificial intelligence and data-driven methods can strengthen project monitoring and support evidence-based decision-making in construction.</p><p>---</p><p>&quot;Evidence Before Execution&quot;</p><p>When my research topic was approved, my first instinct was to start building. I could already picture the dashboard, the charts and the alerts.</p><p>The research process taught me something more valuable: **an approved topic is a direction, not a destination.**</p><p>A topic tells you where to look. A defensible proposal gives that direction purpose, rigour and a credible path to evidence. It must demonstrate:</p><ul><li>Why it matters:** a clearly defined problem grounded in real construction challenges</li><li>What is already known:** a critical review of existing literature and the gaps it leaves open</li><li>How it will be done: realistic objectives, accessible data and a justified methodology</li><li>How success will be judged:** measurable, transparent and reproducible evaluation criteria</li><li>Where it falls short:** an honest account of limitations, rather than an assumption that AI automatically improves outcomes</li></ul><p>That meant reading before building and questioning before assuming. It meant asking what had already been done and what was still missing. Research is not only about finding something nobody has tried. Often it means studying existing work and asking a better, more specific question.</p><p>A research proposal should not merely describe what I intend to build. It should explain why the solution is necessary, how it will be developed, how its performance will be assessed, and what evidence would demonstrate its value.</p><p>The Real Problem: Construction Has Data, but Not Insight</p><p>Construction teams produce a huge amount of information every day:</p><ul><li>Schedules and progress updates</li><li>Material delivery records</li><li>Labour attendance and productivity</li><li>Cost reports</li><li>Weather conditions</li><li>Change orders</li><li>Site photographs</li><li>Safety and rework reports</li></ul><p>Much of it sits in spreadsheets, messaging threads, email chains, paper site diaries and disconnected software.</p><p>A project can look healthy on paper while hiding warning signs:</p><ul><li>A critical delivery is running late</li><li>Labour productivity has dropped</li><li>A design change has triggered rework</li><li>Costs are drifting quietly beyond budget</li><li>Weather has disrupted external works</li><li>One delayed activity is about to affect several others</li></ul><p>The problem is not a lack of data. The data is fragmented, reactive and hard to turn into decisions.</p><p>What BuildSmart360 Aims to Do</p><p>BuildSmart360 is a research prototype designed to answer three practical questions:</p><p>1. Which activities are at risk of delay?<br>2. Why are they at risk?<br>3. What should the project manager consider doing next?</p><p>It will bring together schedule, cost, resource, procurement, weather and risk data to produce:</p><ul><li>A project-health indicator</li><li>Activity-level delay-risk alerts</li><li>The main factors behind each alert</li><li>Suggested corrective actions</li><li>Clear dashboards for project managers</li></ul><p>Instead of reporting only:</p><h3>“Activity 12 is delayed.&quot;</h3><h3>the system aims to say:</h3><h3>&quot;Activity 12 shows high delay risk. The main drivers are a late material delivery, negative schedule variance and reduced labour availability. Suggested actions: expedite procurement, re-sequence dependent activities and review labour allocation.&quot;</h3><p>That is the difference between reporting a problem and supporting a decision.</p><h3>Why Delay Prediction</h3><p>Construction faces many risks, including cost overruns, safety incidents, quality defects and procurement failures. For the first version, I chose to focus on **delay-risk prediction** because delays are:</p><ul><li>Highly visible to clients and stakeholders</li><li>Closely tied to cost overruns<br>- Often linked to measurable operational factors</li><li>Well suited to machine-learning modelling</li><li>Practical to demonstrate in a working prototype</li></ul><h3>How the Research Will Work</h3><p>BuildSmart360 follows a design-science approach. It will be built as a working prototype and evaluated with transparent, reproducible methods that others can scrutinise and replicate.</p><p>1. Ground the data in reality. I will use publicly available construction datasets where possible. If suitable public data is limited, I will build a synthetic dataset grounded in documented delay factors, and I will state clearly that it is synthetic.</p><p>2. Understand the patterns first. Before modelling, I will explore the data. Which factors appear most often in delayed activities? How do procurement problems, weather and cost variance relate to schedule performance?</p><p>3. Choose models with intent. I plan to compare logistic regression, decision trees, random forests and gradient boosting. Each should earn its place through a clear, fair comparison, not because it sounds sophisticated.</p><p>4. Evaluate honestly. Accuracy alone can mislead, especially when delayed activities are far fewer than on-time ones. A model can look impressive simply by predicting that nothing will be late. I will therefore examine precision, recall, F1-score and ROC-AUC. Because a missed delay warning can be costly, recall will receive particular attention.</p><p>5. Make the AI explainable.** If a system flags an activity as high risk, a project manager will reasonably ask, &quot;Why?&quot; Explainability techniques such as SHAP will show which factors drove each prediction, so the output can be questioned, trusted or challenged.</p><p>6. Present it usefully. The prototype will include a project-health view, schedule and cost variance charts, a delay-risk heatmap, high-risk alerts, explanations of delay drivers, suggested actions and a downloadable status report.</p><h3>Why This Research Matters</h3><p>Construction is vital to economies and communities, yet it remains highly vulnerable to delay and cost overruns. AI is increasingly used in construction planning, monitoring, estimation, safety and decision support, but many tools stop at prediction.</p><p>BuildSmart360’s intended contribution is to connect prediction to explanation and action.</p><p>It does not only ask, &quot;Will this activity be delayed?&quot; It asks:</p><ul><li>Why might it be delayed?</li><li>Which factors are driving the risk?</li><li>What can the project team do about it now?</li></ul><h3>Who Could Benefit</h3><ul><li>Project managers** gain earlier visibility into emerging risks and clearer guidance on responses.</li><li>Contractors** can plan resources better and reduce avoidable delays.<br>- **Clients and developers** receive more transparent progress reporting.</li><li>Construction professionals** can shift from firefighting to proactive control.</li><li>Data science learners** see how AI can address a practical industry problem with accessible tools.</li></ul><h3>What BuildSmart360 Will Not Do (Yet)</h3><p>A credible proposal is honest about its limits. The first version will not include drone monitoring, computer vision, sensor integration, autonomous decision-making or full integration with commercial project systems. These are valuable future directions.</p><p>I also want to be clear that introducing AI does not automatically produce better outcomes. Model performance depends on data quality, and a prototype trained on limited or synthetic data cannot claim to represent every real project. The aim of this study is to test whether fragmented project data can be turned into clear, explainable and actionable insight, and to measure how well that works.</p><h3>The Bigger Picture</h3><p>Looking back at the duplex, the problems were hardly mysterious.</p><p>The late delivery was in the procurement record. The labour shortage was in the attendance data. The rework was in the site report. The cost drift was in the budget update.</p><p>The signals existed. No one saw them together until it was too late.</p><p>BuildSmart360 is my attempt to change that, not by replacing project managers or engineers, but by giving them an early-warning system that sees the signals, explains the risk and supports better decisions before delay becomes disaster.</p><h3>What I Am Taking Away</h3><p>Meaningful innovation does not begin with building a solution as quickly as possible. It begins with understanding the problem deeply enough to build the right one.**</p><p>A topic gives you direction. A well-structured proposal gives that direction purpose, scientific rigour and a credible path to evidence.</p><h3>What Comes Next</h3><p>1. Finalise the dataset and data dictionary<br>2. Conduct exploratory data analysis<br>3. Build and compare delay-prediction models<br>4. Add explainability to the predictions<br>5. Develop the dashboard<br>6. Test the prototype with construction professionals<br>7. Share the results and a working demo</p><p>My thanks to the DataraFlow team and my fellow cohort members for the guidance and thoughtful discussions along this journey.</p><h3>Have you ever worked on a project where a small delay became a major problem? What was the first warning sign you wish you had caught?</h3><p>Share your experience in the comments. It may help shape what BuildSmart360 becomes.</p><h3>Follow along as I document the journey from research proposal to working prototype.*</h3><p>Tags:#Data Science, Construction, #Artificial Intelligence,#Machine Learning, #Project Management, #Research, #DataraFlow</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc5369a25849" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning Python, Learning to Think]]></title>
            <link>https://medium.com/@peculiargold/learning-python-learning-to-think-442492902f62?source=rss-c63b7de8a9bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/442492902f62</guid>
            <dc:creator><![CDATA[Peculiar Robbins]]></dc:creator>
            <pubDate>Fri, 09 Oct 2026 18:22:20 GMT</pubDate>
            <atom:updated>2026-10-09T18:22:20.595Z</atom:updated>
            <content:encoded><![CDATA[<p>Learning Python, Learning to Think</p><p>Week 3 Report: Dataflow Python Internship</p><p>Python, Data Science and Bioinformatics</p><p>Python is the tool. The real skill is how you think through a problem before you write a single line.</p><p>1. Executive Summary</p><p>I began this internship believing Python was about writing impressive code. Three weeks in, I see it differently: programming is problem solving, and how you approach a problem is what sets you apart.</p><p>Week 3 was more manageable than the first two weeks. The material was not easier; my approach was. Tasks that once left me staring at a blank screen for hours now broke down into clear steps. This week I covered modules, packages, libraries and virtual environments, error handling, and the datetime module, and I applied them in a small DNA sequence analyzer connected to my interest in bioinformatics.</p><p>Figure 1. The problem-solving process I now follow</p><p>---</p><p>## 2. Key Developments</p><p>- My original mentor group dissolved because of mentor inactivity. I joined a new group, Cosmic Cortex, whose mentor sessions were motivating and came with extra learning materials.<br>- I changed how I write these reports. Earlier, I tried to teach everything I had learned. After the experts session, I realized a weekly article should be a personal record of progress.<br>- I finished the week&#39;s take-home assignment two days before the deadline, a clear improvement over weeks 1 and 2.</p><p>---</p><p>## 3. Technical Learning</p><p>### 3.1 Modules, Packages and Libraries</p><p>A module is a Python file containing functions and attributes that can be reused in other programs. Built-in examples include `math`, `random` and `datetime`.</p><p>Modules save time. While working on an assignment, I was writing several lines of code to find the greatest common divisor of two numbers before discovering that the `math` module already provides it. The problem shrank to four lines.</p><p>```python<br>import math<br>print(math.gcd(48, 18)) # 6</p><p>from math import pi # import only what you need<br>print(pi)<br>```</p><p>Importing a single function keeps code lighter and removes the need to prefix it with the module name.</p><p>When a project grows, related modules are grouped into packages, which are installed with pip. A library is a larger collection of packages and modules written in advance to serve common project needs.</p><p>```<br>Figure 2. How modules, packages and libraries relate</p><p>+--------------------------------------------------------------+<br>| LIBRARY: a collection of ready-made packages |<br>| |<br>| +----------------------------------+ +-----------------+ |<br>| | PACKAGE: related modules, | | OTHER PACKAGES | |<br>| | installed with pip | | | |<br>| | | | each with its | |<br>| | +-----------+ +-------------+ | | own modules | |<br>| | | MODULE | | MODULE | | | | |<br>| | | math.py | | datetime.py | | | | |<br>| | | gcd() | | datetime | | | | |<br>| | | sqrt(), pi| | timedelta | | | | |<br>| | +-----------+ +-------------+ | | | |<br>| +----------------------------------+ +-----------------+ |<br>+--------------------------------------------------------------+<br>```</p><p>### 3.2 Virtual Environments</p><p>Programmers often work on several projects at once, and each may need different versions of the same dependency. A virtual environment gives each project its own isolated space, so installing or upgrading a package for one project cannot break another.</p><p>```<br>Figure 3. One isolated environment per project (versions illustrative)</p><p>+-----------------+ +----------------------+ +-----------------+<br> | Project A | | Project B | | Project C |<br> | env_a | | env_b | | env_c |<br> | pandas 1.5 | | pandas 2.1 | | requests |<br> | Python 3.10 | | biopython | | Python 3.11 |<br> | | | Python 3.12 | | |<br> +-----------------+ +----------------------+ +-----------------+<br> No shared dependencies, so no conflicts<br>```</p><p>### 3.3 Error Handling</p><p>Programs are used by people, so mistakes and bad input should be expected. Python&#39;s `try` and `except` blocks let a program respond to failure instead of crashing, and the `raise` keyword signals a specific error when a condition is not met. Thinking through what could go wrong is part of the design, not an afterthought.</p><p>```<br>Figure 4. Flow of try and except handling</p><p>valid +--------------------------+<br> +-----------&gt;| Continue processing |<br> +------------+ +---+--------+ +--------------------------+<br> | User input |--&gt;| try: |<br> +------------+ | validate | +--------------------------+<br> +---+--------+ | except: message, |<br> +-----------&gt;| retry or exit |<br> invalid +--------------------------+<br>```</p><p>```python<br>try:<br> sequence = input(&quot;Enter a DNA sequence: &quot;).upper()<br> if not set(sequence) &lt;= set(&quot;ATGC&quot;):<br> raise ValueError(&quot;Only A, T, G and C are allowed.&quot;)<br>except ValueError as error:<br> print(f&quot;Invalid input: {error}&quot;)<br>```</p><p>### 3.4 The datetime Module</p><p>I worked with `datetime` extensively this week. It supports date calculations and lets me present dates in any format a task requires.</p><p>```python<br>from datetime import datetime, timedelta</p><p>today = datetime.now()<br>deadline = today + timedelta(days=7)<br>print(deadline.strftime(&quot;%d %B %Y&quot;))<br>```</p><p>---</p><p>## 4. Project: DNA Sequence Analyzer</p><p>Because I finished early, I used the extra time to apply the week&#39;s concepts to bioinformatics by building a simple analyzer that reports the base composition of a DNA sequence.</p><p>My first version counted each base with a separate variable, which made the code crowded and repetitive. I stepped back and asked which data type fit the problem. A dictionary was the answer: bases become keys, counts become values, and a single loop does the work.</p><p>```<br>Figure 5. Choosing the right data type simplified the design</p><p>BEFORE AFTER<br> +-------------------------------+ +-------------------------------+<br> | a_count, t_count, | | counts = {&quot;A&quot;:0, &quot;T&quot;:0, |<br> | g_count, c_count | ---&gt; | &quot;G&quot;:0, &quot;C&quot;:0} |<br> | repeated if / elif logic | | one dictionary, one loop |<br> +-------------------------------+ +-------------------------------+<br>```</p><p>```python<br>sequence = &quot;ATGCGATACGCTTGA&quot;<br>counts = {&quot;A&quot;: 0, &quot;T&quot;: 0, &quot;G&quot;: 0, &quot;C&quot;: 0}</p><p>for base in sequence:<br> counts[base] += 1</p><p>print(counts)<br>```</p><p>I originally planned to store sequences in a database and query them with SQL. This week introduced `JOIN`, `ORDER BY`, `SELECT`, `DESC` and `LIMIT`, but I did not have time to practice them on this project. That is the first goal for week 4.</p><p>---</p><p>## 5. Reflection: Time and Perfectionism</p><p>In the first two weeks I often submitted just minutes before the deadline. It was not carelessness; I wanted every submission to be worthwhile. That approach cost me my week 1 submission, despite the effort I had put in. The lesson was clear: the pursuit of perfection can make you miss the opportunity itself. This week, planning ahead and accepting good work delivered on time made the difference.</p><p>---</p><p>## 6. Week at a Glance</p><p>| Area | What I learned | Next step |<br>|---|---|---|<br>| Modules and libraries | Reuse tested code; import only what you need | Explore more standard modules |<br>| Packages and environments | Organize code; isolate dependencies per project | Use a virtual environment for every project |<br>| Data types | A dictionary replaced repetitive counters | Extend the sequence analyzer |<br>| Error handling | `try`, `except` and `raise` keep programs from crashing | Validate all user input |<br>| SQL | JOIN, ORDER BY, SELECT, DESC, LIMIT | Store sequences in a database |<br>| Time management | Submit early, then refine | Plan work around deadlines |</p><p>---</p><p>## 7. Looking Ahead</p><p>The biggest change after three weeks is not a list of new syntax but a new way of approaching problems. In week 4, I will put SQL to work in the sequence analyzer and continue building the habit of planning before coding.</p><p>&gt; &quot;What can&#39;t break you, will build you.&quot;</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=442492902f62" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Duplex That Taught Me Why Construction Needs Data Science]]></title>
            <link>https://medium.com/@peculiargold/the-duplex-that-taught-me-why-construction-needs-data-science-ac5576fa7ce4?source=rss-c63b7de8a9bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac5576fa7ce4</guid>
            <dc:creator><![CDATA[Peculiar Robbins]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 00:01:27 GMT</pubDate>
            <atom:updated>2026-10-09T19:38:46.638Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>THE DUPLEX THAT TAUGHT ME WHY CONSTRUCTION NEEDS DATA SCIENCE DATARAFLOW JOURNEY WEEKS 4 &amp; 5 FROM A REJECTED IDEA TO A RESEARCH PROPOSAL</strong></h4><p>Fourteen problems on one renovation. Every one was visible weeks before it hurt. This is how they became my approved AI research topic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/1*XZbMJiV0jqDF_Q6KZSHNWw.png" /></figure><p>Photo: the duplex renovation site (replace with your own)</p><h3>A week before handover, the client called with one question:</h3><h4>“Why are the upstairs bathrooms still not finished?”</h4><p>Nobody could answer it. Everyone held one piece of the truth. The plumber was late. The tiles had run out. The screed was uneven. The roof had leaked into fresh plaster. A supplier was two weeks behind, workers had missed days, and a payment was on hold.</p><p>The uncomfortable part: every one of those problems had been visible weeks earlier, sitting in WhatsApp photos, phone calls, half-filled notebooks and people&#39;s memories. Nobody could see them all at once.</p><p>That is why I&#39;m building BuildSmart360.</p><h4>Week 4: from learning to building</h4><p>This is Week 4 of my data science journey. For three weeks I studied Python, data structures and the basics of analysis. This week I stopped asking “what should I learn next?” and asked a harder question:</p><h4><em>What real problem can I solve with what I&#39;ve learned</em>?</h4><p>I learnt a new library and I picked a real-world problem and shaped it into a formal research proposal.</p><p>The answer came from my past. Before data science, I worked in tiling, decorative stonework and masonry, trades where a 3 mm error or a wrong order quantity can wreck a whole schedule.</p><p>So I proposed a research topic that joins both worlds, and it was approved this week. The project now moves from concept to structured research.</p><h4>The Approved Topic</h4><h3>BuildSmart360: An AI-Powered Construction Project Monitoring and Decision Support System.</h3><h4>The Problem</h4><p>Construction and renovation projects often run late, go over budget, and suffer from scattered information. Progress updates, schedules, material quantities, payments, and site conditions are spread across paper reports, spreadsheets, WhatsApp messages, and verbal updates. Because of this, project teams often spot problems only after they have become expensive.<br>The core issue isn’t a lack of data. Construction sites produce plenty of it. The issue is that the data is rarely combined, analysed, or turned into timely insight.</p><h4>The project: a four-bedroom duplex, full renovation</h4><p>The scope covered structural repairs, roofing, plumbing, rewiring, screeding, POP ceilings, tiling, a stone feature wall, painting, joinery and external masonry. The client had a fixed move-in date. Looking back, the 14 problems fall into four patterns.</p><h4>1. Surprises with no buffer</h4><ul><li>Hidden defects. Stripping the old finishes revealed cracked beams and damp walls. Work stopped for an engineer, and the budget had no contingency.</li><li>The late roof. Roofing was scheduled after the interiors. The rains came and ruined a new POP ceiling.</li></ul><h4>2. Trades that collided</h4><ul><li>Late services. Pipes and conduits were still going in when tiling was due. We waited, or tiled areas that were later broken open.</li><li>Untracked design changes. A wall came down, a bathroom grew and the kitchen tiles changed. Quantities, labour, cost and timeline were never updated, which fed later payment disputes.</li><li>Out-of-sequence fittings. Frames and doors went in before or after the finishes around them, and finished surfaces were damaged.</li></ul><h4>3. Materials nobody was tracking</h4><ul><li>Running out of tiles. The order was based on the old floor plan. The original batch was gone, and the replacement had a visible shade difference.</li><li>Invisible waste. Cut-offs, breakages and leftover cement were never recorded. Usage ended far above estimate and nobody could say why.</li><li>Moving suppliers and prices. The stone arrived two weeks late, and cement and adhesive prices rose mid-project.</li></ul><h4>4. Problems found too late</h4><ul><li>Uneven screed. It should have been caught at inspection. We found it after tiling, as hollow tiles and lippage.</li><li>Painting over damp plaster. Painting started early to recover time, and within weeks the paint was bubbling.</li><li>Labour gaps. Missed days and workers moving to other sites eroded output a little at a time.</li><li>Cash-flow stalls. Delayed payments slowed work and broke trust.</li><li>External works left last. Fencing, stair masonry and paving were rushed at the end.</li></ul><p>Underneath all of it sat the fourteenth problem: no single source of truth. There was no plan-versus-actual view and no forecast. The delay only became official when the client asked about it.</p><p>The outcome: a handover weeks late, a budget overrun, rework in several rooms, an unhappy client and trades blaming each other.</p><h4>The real lesson: it was never a lack of information</h4><h3>Each problem had a warning sign:</h3><ul><li>Design change approved: Recalculate quantities, labour, cost, timelines.</li><li>Tile usage outpacing progress: Waste and shortage alert</li><li>Plumber has 3 days left, tiling starts tomorrow: Dependency clash alert</li><li>Supplier quotes a longer lead time: Reorder and reschedule prompt</li><li>Site photos show uneven screed: Inspection hold before tiling</li><li>Attendance dropping on critical days: Output-risk flag</li></ul><p>The project didn’t lack data. It lacked a way to connect it, analyse it and raise an alert while action was still cheap. That is a data science problem.</p><h4>What BuildSmart360 will do</h4><p>The system turns scattered site information into early warnings and clear decisions, through seven modules:</p><ul><li>Schedule and Dependencies: who works where, when, and after whom</li><li>Material Management: quantities, stock, batch numbers, wastage, suppliers</li><li>Labour and Productivity: attendance and daily output</li><li>Quality and Inspection: checkpoints, defects, rework</li><li>Cost and Payments: budgets, change orders, milestone payments</li><li>Risk Prediction: machine learning for delay, cost and rework risk</li><li>Decision Dashboard: progress, risks and recommended actions in one view</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/654/1*HvA6Pvm1jZ4DwOUrqDaZQw.png" /></figure><p>Figure 1: The seven BuildSmart360 modules feed one risk model and one dashboard.</p><p>The goal is not to replace experienced site teams. It is to give them a shared view, so they can act while problems are still small.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/654/1*m-wFz1NoYQl6w3qeABdhDA.png" /></figure><p>Figure 2: Concept mockup of the BuildSmart360 decision dashboard (illustrative data)</p><h4>The research questions</h4><ol><li>How can fragmented construction data be unified into one monitoring framework?</li><li>Which indicators best predict delays, cost overruns and rework?</li><li>How accurately can machine learning flag project risks before they become critical?</li><li>How should AI insights be presented so site teams actually use them?</li></ol><p>The fourth question matters most. A model nobody trusts or reads is just a spreadsheet with extra steps.</p><h4>Why a tiler belongs in data science</h4><p>Data science is usually associated with sales dashboards and finance models. Yet some of the richest data sits on construction sites, and most of it goes unused.</p><p>My trade background gives me what a textbook can’t. I know what a hollow tile sounds like. I know what it costs when a batch runs out. I know how one late trade knocks every other trade off schedule. Python and machine learning give me the tools. Site experience tells me where to point them.</p><h4>What&#39;s next</h4><ul><li>Sharpen the problem statement using real cases like this duplex</li><li>Review research on construction monitoring and AI in project management</li><li>Identify realistic data sources</li><li>Design the methodology and select models</li><li>Build a sample dataset to test the first models</li></ul><p>I&#39;ll share each step here, including the mistakes.</p><h4>Key takeaway</h4><p>Data science isn&#39;t only about mastering tools. It&#39;s about finding problems worth solving. Mine was hiding in a duplex renovation, scattered across phone calls, photos and missed warning signs.</p><p>One topic approved. One step closer to BuildSmart360.</p><p>Your turn: What’s the most expensive problem you’ve seen on a construction site that better data could have prevented? Share it in the comments. It might shape what BuildSmart360 becomes.</p><p>Follow along for Week 5, where the research begins.</p><p>Tags: #Data Science, #Python #Construction, #Artificial Intelligence, #Machine Learning, #Project Management</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac5576fa7ce4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning Python, Learning to Think]]></title>
            <link>https://medium.com/@peculiargold/learning-python-learning-to-think-7360d0190ef6?source=rss-c63b7de8a9bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/7360d0190ef6</guid>
            <dc:creator><![CDATA[Peculiar Robbins]]></dc:creator>
            <pubDate>Sun, 04 Oct 2026 16:23:44 GMT</pubDate>
            <atom:updated>2026-10-04T16:23:44.068Z</atom:updated>
            <content:encoded><![CDATA[<p>Learning Python, Learning to Think</p><p>Week 3 Report: Dataflow Python Internship<br> Python, Data Science and Bioinformatics</p><p>Python is the tool. The real skill is how you think through a problem before you write a single line.</p><p>1. Executive Summary</p><p>I began this internship believing Python was about writing impressive code. Three weeks in, I see it differently: programming is problem solving, and how you approach a problem is what sets you apart.</p><p>Week 3 was more manageable than the first two weeks. The material was not easier; my approach was. Tasks that once left me staring at a blank screen for hours now broke down into clear steps. This week I covered modules, packages, libraries and virtual environments, error handling, and the datetime module, and I applied them in a small DNA sequence analyzer connected to my interest in bioinformatics.</p><p>Figure 1. The problem-solving process I now follow</p><p>+------------+ +--------+ +-------------+ +--------+ +------------+ +-----------+<br> | Understand |--&gt;| Plan |--&gt;| Choose |--&gt;| Write |--&gt;| Anticipate |--&gt;| Test |<br> | the problem| | logic | | data+tools | | code | | errors | | &amp; refine |<br> +------------+ +--------+ +-------------+ +--------+ +------------+ +-----------+<br> ^ |<br> +------------------------------ refine and repeat -----------------------------+</p><p>2. Key Developments</p><p>- My original mentor group dissolved because of mentor inactivity. I joined a new group, Cosmic Cortex, whose mentor sessions were motivating and came with extra learning materials.<br>- I changed how I write these reports. Earlier, I tried to teach everything I had learned. After the experts session, I realized a weekly article should be a personal record of progress.<br>- I finished the week&#39;s take-home assignment two days before the deadline, a clear improvement over weeks 1 and 2.</p><p>3. Technical Learning</p><p>3.1 Modules, Packages and Libraries</p><p>A module is a Python file containing functions and attributes that can be reused in other programs. Built-in examples include `math`, `random` and `datetime`.</p><p>Modules save time. While working on an assignment, I was writing several lines of code to find the greatest common divisor of two numbers before discovering that the `math` module already provides it. The problem shrank to four lines.</p><p>python<br>import math<br>print(math.gcd(48, 18)) # 6</p><p>from math import pi # import only what you need<br>print(pi)</p><p>Importing a single function keeps code lighter and removes the need to prefix it with the module name.</p><p>When a project grows, related modules are grouped into packages, which are installed with pip. A library is a larger collection of packages and modules written in advance to serve common project needs.</p><p>code<br>Figure 2. How modules, packages and libraries relate</p><p>+--------------------------------------------------------------+<br>| LIBRARY: a collection of ready-made packages |<br>| |<br>| +----------------------------------+ +-----------------+ |<br>| | PACKAGE: related modules, | | OTHER PACKAGES | |<br>| | installed with pip | | | |<br>| | | | each with its | |<br>| | +-----------+ +-------------+ | | own modules | |<br>| | | MODULE | | MODULE | | | | |<br>| | | math.py | | datetime.py | | | | |<br>| | | gcd() | | datetime | | | | |<br>| | | sqrt(), pi| | timedelta | | | | |<br>| | +-----------+ +-------------+ | | | |<br>| +----------------------------------+ +-----------------+ |<br>+--------------------------------------------------------------+</p><p>3.2 Virtual Environments</p><p>Programmers often work on several projects at once, and each may need different versions of the same dependency. A virtual environment gives each project its own isolated space, so installing or upgrading a package for one project cannot break another.</p><p>code<br>Figure 3. One isolated environment per project (versions illustrative)</p><p>+-----------------+ +----------------------+ +-----------------+<br> | Project A | | Project B | | Project C |<br> | env_a | | env_b | | env_c |<br> | pandas 1.5 | | pandas 2.1 | | requests |<br> | Python 3.10 | | biopython | | Python 3.11 |<br> | | | Python 3.12 | | |<br> +-----------------+ +----------------------+ +-----------------+<br> No shared dependencies, so no conflicts</p><p>3.3 Error Handling</p><p>Programs are used by people, so mistakes and bad input should be expected. Python&#39;s `try` and `except` blocks let a program respond to failure instead of crashing, and the `raise` keyword signals a specific error when a condition is not met. Thinking through what could go wrong is part of the design, not an afterthought.</p><p>code<br>Figure 4. Flow of try and except handling</p><p>valid +--------------------------+<br> +-----------&gt;| Continue processing |<br> +------------+ +---+--------+ +--------------------------+<br> | User input |--&gt;| try: |<br> +------------+ | validate | +--------------------------+<br> +---+--------+ | except: message, |<br> +-----------&gt;| retry or exit |<br> invalid +--------------------------+</p><p>python<br>try:<br> sequence = input(&quot;Enter a DNA sequence: &quot;).upper()<br> if not set(sequence) &lt;= set(&quot;ATGC&quot;):<br> raise ValueError(&quot;Only A, T, G and C are allowed.&quot;)<br>except ValueError as error:<br> print(f&quot;Invalid input: {error}&quot;)</p><p>3.4 The datetime Module</p><p>I worked with `datetime` extensively this week. It supports date calculations and lets me present dates in any format a task requires.</p><p>python<br>from datetime import datetime, timedelta</p><p>today = datetime.now()<br>deadline = today + timedelta(days=7)<br>print(deadline.strftime(&quot;%d %B %Y&quot;))</p><p>4. Project: DNA Sequence Analyzer</p><p>Because I finished early, I used the extra time to apply the week&#39;s concepts to bioinformatics by building a simple analyzer that reports the base composition of a DNA sequence.</p><p>My first version counted each base with a separate variable, which made the code crowded and repetitive. I stepped back and asked which data type fit the problem. A dictionary was the answer: bases become keys, counts become values, and a single loop does the work.</p><p>code<br>Figure 5. Choosing the right data type simplified the design</p><p>BEFORE AFTER<br> +-------------------------------+ +-------------------------------+<br> | a_count, t_count, | | counts = {&quot;A&quot;:0, &quot;T&quot;:0, |<br> | g_count, c_count | ---&gt; | &quot;G&quot;:0, &quot;C&quot;:0} |<br> | repeated if / elif logic | | one dictionary, one loop |<br> +-------------------------------+ +-------------------------------+</p><p>python<br>sequence = &quot;ATGCGATACGCTTGA&quot;<br>counts = {&quot;A&quot;: 0, &quot;T&quot;: 0, &quot;G&quot;: 0, &quot;C&quot;: 0}</p><p>for base in sequence:<br> counts[base] += 1</p><p>print(counts)</p><p>I originally planned to store sequences in a database and query them with SQL. This week introduced `JOIN`, `ORDER BY`, `SELECT`, `DESC` and `LIMIT`, but I did not have time to practice them on this project. That is the first goal for week 4.</p><p>5. Reflection: Time and Perfectionism</p><p>In the first two weeks I often submitted just minutes before the deadline. It was not carelessness; I wanted every submission to be worthwhile. That approach cost me my week 1 submission, despite the effort I had put in. The lesson was clear: the pursuit of perfection can make you miss the opportunity itself. This week, planning ahead and accepting good work delivered on time made the difference.</p><p>6. Week at a Glance</p><p>| Area | What I learned | Next step |<br>|---|---|---|<br>| Modules and libraries | Reuse tested code; import only what you need | Explore more standard modules |<br>| Packages and environments | Organize code; isolate dependencies per project | Use a virtual environment for every project |<br>| Data types | A dictionary replaced repetitive counters | Extend the sequence analyzer |<br>| Error handling | `try`, `except` and `raise` keep programs from crashing | Validate all user input |<br>| SQL | JOIN, ORDER BY, SELECT, DESC, LIMIT | Store sequences in a database |<br>| Time management | Submit early, then refine | Plan work around deadlines |</p><p>7. Looking Ahead</p><p>The biggest change after three weeks is not a list of new syntax but a new way of approaching problems. In week 4, I will put SQL to work in the sequence analyzer and continue building the habit of planning before coding.</p><p>&quot;What can’t break you, will build you.&quot;</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7360d0190ef6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Python Fundamentals to My First Object-Oriented System]]></title>
            <link>https://medium.com/@peculiargold/from-python-fundamentals-to-my-first-object-oriented-system-15abb97b0dbc?source=rss-c63b7de8a9bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/15abb97b0dbc</guid>
            <dc:creator><![CDATA[Peculiar Robbins]]></dc:creator>
            <pubDate>Sat, 19 Sep 2026 16:16:38 GMT</pubDate>
            <atom:updated>2026-09-19T16:16:38.087Z</atom:updated>
            <content:encoded><![CDATA[<p>From Python Fundamentals to My First Object-Oriented System</p><p>Week 2 in review: classes, inheritance, iterators, polymorphism, and scope**</p><p>In Week 1, I learned the building blocks of Python — variables, control flow, functions, data structures, and file handling. Week 2 marked a shift: instead of writing scripts that performed a single task, I began learning how to *design* programs around objects, structure, and reusable behavior. New vocabulary appeared quickly — `__init__()`, `super()`, iterators, polymorphism, `global`/`nonlocal`, and Method Resolution Order — but working through small, isolated examples before combining them into a larger project made the concepts click. By the end of the week, my question had evolved from &quot;how do I make this work?&quot; to &quot;how should this be structured?&quot;</p><p>1. Classes and Objects</p><p>A class is a blueprint; an object is an instance of it, with attributes (data) and methods (behavior):</p><p>python<br>class Person:<br> def __init__(self, name, age):<br> self.name = name<br> self.age = age</p><p>def introduce(self):<br> print(f&quot;My name is {self.name} and I am {self.age} years old.&quot;)</p><p>person1 = Person(&quot;John&quot;, 36)<br>person1.introduce()<br>```</p><p>`__init__()` runs automatically on object creation, and `self` gives each instance access to its own state. Learning `__str__()` for human-readable object representations reinforced that Python code can model real-world entities rather than just a sequence of steps.</p><p>2. Inheritance</p><p>Inheritance lets a child class reuse a parent&#39;s attributes and methods, avoiding duplication:</p><p>python<br>class Student(Person):<br> def __init__(self, fname, lname, year):<br> super().__init__(fname, lname)<br> self.graduation_year = year</p><p>`super()` calls the parent&#39;s constructor, so the child only adds what&#39;s new. I practiced this pattern across animals, shapes, bank accounts, and vehicles before applying it to books and library members.</p><p>3. Iterators</p><p>Iterators exposed what actually happens behind a `for` loop — the `__iter__()` and `__next__()` protocol, plus `iter()`/`next()` and the `StopIteration` signal:</p><p>python<br>class CountDown:<br> def __init__(self, n):<br> self.n = n</p><p>def __iter__(self):<br> return self</p><p>def __next__(self):<br> if self.n &gt;= 1:<br> value = self.n<br> self.n -= 1<br> return value<br> raise StopIteration</p><p>Building custom iterators (a countdown, an even-number generator) made it clear that a `for` loop hides meaningful internal machinery.</p><p>4. Polymorphism</p><p>Different classes can implement the same method name with different behavior:</p><p>python<br>class Car:<br> def move(self): print(&quot;Car drives&quot;)</p><p>class Bicycle:<br> def move(self): print(&quot;Bicycle pedals&quot;)</p><p>for vehicle in [Car(), Bicycle()]:<br> vehicle.move()</p><p>The same call, `vehicle.move()`, resolves differently per object — a concept that becomes especially useful when combined with inheritance and method overriding.</p><p>5. Scope and Encapsulation</p><p>I worked through local, global, enclosing, and built-in scope, along with `global` and `nonlocal`. A local variable named `len`, for instance, demonstrated how a name can shadow a built-in within its own scope. This section reframed how I think about Python: understanding a program means understanding not just *what* a line does, but *where* Python resolves each name from.</p><p>6. Capstone: A Library Management System</p><p>The week&#39;s concepts converged in a single project — a library system built around:</p><p>-Inheritance: a base `Book` class with `EBook` and `PrintedBook` subclasses; a `Member` base class with `StudentMember` and `TeacherMember` subclasses.<br>- Polymorphism: a `get_description()` method defined once in the parent and overridden per subclass, callable uniformly via `book.get_description()`; borrowing limits that differ by member type.<br>- Iterators: making `Library` and `Member` iterable, to loop over the full catalog or a member’s borrowed books.<br>- Encapsulation: a protected `_borrowed_books` attribute on `Member`, a private `__library_name` on `Library` with getter/setter access, and a class-level counter tracking total books borrowed system-wide.</p><p>The finished system stores multiple book and member types, tracks availability and borrowing, supports search by title or author, and enforces role-based borrowing limits.</p><p>7. Key Challenges</p><p>The hardest part wasn’t memorizing syntax — it was distinguishing concepts that look similar on the surface. Inheritance and polymorphism both involve classes and methods, which made them easy to conflate at first. Iterators resolved once I saw them as one pipeline:<br>iter() → obtains an iterator<br>next() → retrieves the next item<br>__iter__() → defines how an object becomes iterable<br>__next__() → defines what &quot;next&quot; means<br>StopIteration → signals exhaustion</p><p>Scope was the biggest mental shift, since the same variable name can resolve to different values depending on where it&#39;s referenced.</p><p>8. Takeaways</p><p>Week 1 taught me to write Python. Week 2 taught me to *design* it. I now have a working sense of why classes reduce repetition through inheritance, how polymorphism lets different objects respond to a shared interface, how iteration works under the hood, and how scope governs name resolution. The library system was the turning point — it forced me to ask *where inheritance actually earns its place in a real program, not just how to define it in isolation. Heading into Week 3, my approach stays the same: learn the concept, write the code, break it, understand why, fix it, then apply it.</p><p>Want this as a downloadable Word doc or Markdown file, or adapted for a specific platform (e.g., LinkedIn, a portfolio site, or dev.to)?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=15abb97b0dbc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What I Learned in My First Week of Data Science]]></title>
            <link>https://medium.com/@peculiargold/what-i-learned-in-my-first-week-of-data-science-ee4c667a85a7?source=rss-c63b7de8a9bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee4c667a85a7</guid>
            <dc:creator><![CDATA[Peculiar Robbins]]></dc:creator>
            <pubDate>Tue, 08 Sep 2026 20:17:30 GMT</pubDate>
            <atom:updated>2026-09-08T20:17:30.001Z</atom:updated>
            <content:encoded><![CDATA[<p>What I Learned in My First Week of Data Science</p><p>Starting a data science journey comes with a mix of excitement and, honestly, a bit of overwhelm. There are so many tools, so many buzzwords, and so many opinions on what data science &quot;really&quot; is. My first week was less about writing code and more about resetting my understanding of what this field actually involves — and I think that reset was more valuable than any tool I installed.</p><p><strong>Getting the Environment Ready</strong><br>Before diving into any real work, step one was setup: getting all the recommended software installed and configured. It’s a small milestone, but an important one. There’s a quiet satisfaction in having a clean, working environment — it removes friction later and means the next time I sit down to learn, I can focus on concepts instead of troubleshooting installs.</p><p><strong>Data Science Isn’t About the Tools</strong><br>The biggest mental shift for me this week came from a video that reframed how I think about the entire field.</p><p>Data science, at its core, is about using data to create insights — to build product recommendations, develop data products, and ultimately solve problems for a business. That’s it. That’s the job.</p><p>What I Learned in My First Week of Data Science<br>Starting a data science journey comes with a mix of excitement and, honestly, a bit of overwhelm. There are so many tools, so many buzzwords, and so many opinions on what data science &quot;really&quot; is. My first week was less about writing code and more about resetting my understanding of what this field actually involves — and I think that reset was more valuable than any tool I installed.<br>Getting the Environment Ready<br>Before diving into any real work, step one was setup: getting all the recommended software installed and configured. It’s a small milestone, but an important one. There’s a quiet satisfaction in having a clean, working environment — it removes friction later and means the next time I sit down to learn, I can focus on concepts instead of troubleshooting installs.<br>Data Science Isn’t About the Tools<br>The biggest mental shift for me this week came from a video that reframed how I think about the entire field.<br>Data science, at its core, is about using data to create insights — to build product recommendations, develop data products, and ultimately solve problems for a business. That’s it. That’s the job.<br>It’s easy to get pulled into thinking data science is Python, or is machine learning, or is whatever tool happens to be trending. But the tools are just how the work gets done. The real value is in identifying the right problem and solving it well. A perfectly built model that answers the wrong question is worth far less than a simple analysis that answers the right one.<br>The Data Science Hierarchy of Needs<br>The second big idea I picked up was the Data Science Hierarchy of Needs — a framework for understanding how the responsibilities of a data scientist shift depending on the size and stage of the company they work for.<br>At startups, data scientists tend to wear every hat. There’s no dedicated infrastructure team or analytics department to hand things off to, so the data scientist ends up touching everything — from collecting and cleaning data, to building pipelines, to analysis, to modeling.<br>At larger companies, roles become more specialized. Data scientists here spend most of their time on analytics, tracking metrics, and preparing training data. This is where the bulk of real, everyday data science work actually happens.<br>What struck me most was the gap between perception and reality. Media coverage tends to spotlight AI and deep learning as the face of data science — flashy models, self-driving cars, generative AI breakthroughs. But in practice, that work is a narrow, specialized slice of the field, usually owned by dedicated AI researchers rather than the average data scientist. Most of the actual work in the industry is quieter: understanding data, building solid metrics, and making sure the business has what it needs to make good decisions.<br>Why This Matters for Beginners<br>I think this is an important reset for anyone starting out. It’s tempting to jump straight into machine learning algorithms because that’s the &quot;exciting&quot; part. But if the foundation — understanding the problem, working with data, building reliable analytics — isn’t solid, the fancy modeling doesn’t mean much.<br>Coming out of this first week, my mindset has shifted from &quot;What tools do I need to learn?&quot; to &quot;What problems am I trying to solve, and what does the data tell me about them?&quot; That feels like the right question to be asking this early on.<br>Why the Hierarchy of Needs Matters More Than It Seems<br>The reason this framework stuck with me is that it changes how I plan my own learning. If I had gone in assuming data science = machine learning, I would have rushed straight to algorithms and skipped the unglamorous — but essential — layers underneath: data collection, cleaning, exploration, and metrics. Those layers are the foundation everything else sits on. Skipping them is like trying to build the roof of a house before the walls exist.<br>It also reframes how I think about career paths. Not every data scientist needs to become a machine learning expert, and that’s fine. Plenty of impactful, well-paid, respected work in this field is analytics and metrics work — the &quot;boring middle&quot; that actually keeps companies running. Knowing this early helps me set realistic expectations instead of chasing a narrow, hyped version of the job.<br>Steps to Get Great Results While Learning Data Science<br>Learning a field this broad can get overwhelming fast, so here are the principles I’m using to stay focused and actually retain what I learn — not just move through material.<br>1. Learn the &quot;why&quot; before the &quot;how.&quot;<br>Before touching a tool or writing a line of code, I try to understand what problem it’s solving and why it exists. Tools change constantly; the underlying problems they solve usually don’t. Understanding the &quot;why&quot; makes it much easier to pick up new tools later, because I’m not memorizing syntax — I’m recognizing a familiar problem wearing a different outfit.<br>2. Anchor every concept to a real problem.<br>Instead of learning statistics or Python in the abstract, I try to tie each new concept to a concrete business question: How would this help a company understand its customers? How would this improve a product? Concepts stick far better when they’re attached to a purpose.<br>3. Respect the hierarchy — don’t skip levels.<br>Based on the hierarchy of needs, I’m deliberately spending more time on data fundamentals — cleaning, structuring, and understanding data — before jumping into modeling. It’s less exciting, but it’s where most real-world data science time actually goes, so it’s worth building real competence here first.<br>4. Build small, complete projects instead of collecting tutorials.<br>Watching videos and reading articles feels productive, but it’s easy to mistake &quot;watching&quot; for &quot;learning.&quot; A better test is: can I take a small, messy dataset and produce a simple insight or report from it, start to finish, on my own? Small complete projects build real confidence and expose gaps that passive learning hides.<br>5. Get comfortable with being uncomfortable.<br>Data science involves a lot of not knowing — the right approach, the right tool, or even the right question. Progress often comes from sitting with that discomfort long enough to investigate, rather than jumping to the first tutorial that promises a shortcut.<br>6. Track what confuses you, and revisit it.<br>Keeping a running list of concepts that didn’t fully click has been useful. Revisiting them a week later — after more context has built up — usually makes them click much faster the second time around.<br>7. Separate &quot;interesting&quot; from &quot;important.&quot;<br>AI and deep learning are genuinely interesting, and it’s natural to be drawn to them. But recognizing that they represent a specialized slice of the field — not the daily reality for most data scientists — helps me prioritize learning what’s actually going to be useful day-to-day: data wrangling, analysis, and communicating findings clearly.<br>The reason this framework stuck with me is that it changes how I plan my own learning. If I had gone in assuming data science = machine learning, I would have rushed straight to algorithms and skipped the unglamorous — but essential — layers underneath: data collection, cleaning, exploration, and metrics. Those layers are the foundation everything else sits on. Skipping them is like trying to build the roof of a house before the walls exist.<br>It also reframes how I think about career paths. Not every data scientist needs to become a machine learning expert, and that’s fine. Plenty of impactful, well-paid, respected work in this field is analytics and metrics work — the &quot;boring middle&quot; that actually keeps companies running. Knowing this early helps me set realistic expectations instead of chasing a narrow, hyped version of the job.<br>Steps to Get Great Results While Learning Data Science<br>Learning a field this broad can get overwhelming fast, so here are the principles I’m using to stay focused and actually retain what I learn — not just move through material.<br>1. Learn the &quot;why&quot; before the &quot;how.&quot;<br>Before touching a tool or writing a line of code, I try to understand what problem it’s solving and why it exists. Tools change constantly; the underlying problems they solve usually don’t. Understanding the &quot;why&quot; makes it much easier to pick up new tools later, because I’m not memorizing syntax — I’m recognizing a familiar problem wearing a different outfit.<br>2. Anchor every concept to a real problem.<br>Instead of learning statistics or Python in the abstract, I try to tie each new concept to a concrete business question: How would this help a company understand its customers? How would this improve a product? Concepts stick far better when they’re attached to a purpose.<br>3. Respect the hierarchy — don’t skip levels.<br>Based on the hierarchy of needs, I’m deliberately spending more time on data fundamentals — cleaning, structuring, and understanding data — before jumping into modeling. It’s less exciting, but it’s where most real-world data science time actually goes, so it’s worth building real competence here first.<br>4. Build small, complete projects instead of collecting tutorials.<br>Watching videos and reading articles feels productive, but it’s easy to mistake &quot;watching&quot; for &quot;learning.&quot; A better test is: can I take a small, messy dataset and produce a simple insight or report from it, start to finish, on my own? Small complete projects build real confidence and expose gaps that passive learning hides.<br>5. Get comfortable with being uncomfortable.<br>Data science involves a lot of not knowing — the right approach, the right tool, or even the right question. Progress often comes from sitting with that discomfort long enough to investigate, rather than jumping to the first tutorial that promises a shortcut.<br>6. Track what confuses you, and revisit it.<br>Keeping a running list of concepts that didn’t fully click has been useful. Revisiting them a week later — after more context has built up — usually makes them click much faster the second time around.<br>7. Separate &quot;interesting&quot; from &quot;important.&quot;<br>AI and deep learning are genuinely interesting, and it’s natural to be drawn to them. But recognizing that they represent a specialized slice of the field — not the daily reality for most data scientists — helps me prioritize learning what’s actually going to be useful day-to-day: data wrangling, analysis, and communicating findings clearly. <br>Looking Ahead<br>I’m still right at the beginning, but I already feel like I have a clearer map of the terrain — what data science actually is, where the real work happens, and where the hype tends to live. My next steps are to build on this foundation with actual data work: cleaning,</p><p><strong>The Data Science Hierarchy of Needs<br>The second big idea I picked up was the Data Science Hierarchy of Needs — a framework for understanding how the responsibilities of a data scientist shift depending on the size and stage of the company they work for.</strong></p><p><strong>At startups, data scientists tend to wear every hat. There’s no dedicated infrastructure team or analytics department to hand things off to, so the data scientist ends up touching everything — from collecting and cleaning data, to building pipelines, to analysis, to modeling.</strong></p><p><strong>At larger companies, roles become more specialized. Data scientists here spend most of their time on analytics, tracking metrics, and preparing training data. This is where the bulk of real, everyday data science work actually happens.</strong></p><p><strong>What struck me most was the gap between perception and reality. Media coverage tends to spotlight AI and deep learning as the face of data science — flashy models, self-driving cars, generative AI breakthroughs. But in practice, that work is a narrow, specialized slice of the field, usually owned by dedicated AI researchers rather than the average data scientist. Most of the actual work in the industry is quieter: understanding data, building solid metrics, and making sure the business has what it needs to make good decisions.</strong></p><p><strong>Why This Matters for Beginners<br>I think this is an important reset for anyone starting out. It’s tempting to jump straight into machine learning algorithms because that’s the &quot;exciting&quot; part. But if the foundation — understanding the problem, working with data, building reliable analytics — isn’t solid, the fancy modeling doesn’t mean much.</strong></p><p><strong>Coming out of this first week, my mindset has shifted from &quot;What tools do I need to learn?&quot; to &quot;What problems am I trying to solve, and what does the data tell me about them?&quot; That feels like the right question to be asking this early on.</strong></p><p><strong>Why the Hierarchy of Needs Matters More Than It Seems<br>The reason this framework stuck with me is that it changes how I plan my own learning. If I had gone in assuming data science = machine learning, I would have rushed straight to algorithms and skipped the unglamorous — but essential — layers underneath: data collection, cleaning, exploration, and metrics. Those layers are the foundation everything else sits on. Skipping them is like trying to build the roof of a house before the walls exist.</strong></p><p><strong>It also reframes how I think about career paths. Not every data scientist needs to become a machine learning expert, and that’s fine. Plenty of impactful, well-paid, respected work in this field is analytics and metrics work — the &quot;boring middle&quot; that actually keeps companies running. Knowing this early helps me set realistic expectations instead of chasing a narrow, hyped version of the job.</strong></p><p><strong>Steps to Get Great Results While Learning Data Science<br>Learning a field this broad can get overwhelming fast, so here are the principles I’m using to stay focused and actually retain what I learn — not just move through material.<br>1. Learn the &quot;why&quot; before the &quot;how.&quot;</strong></p><p><strong>Before touching a tool or writing a line of code, I try to understand what problem it’s solving and why it exists. Tools change constantly; the underlying problems they solve usually don’t. Understanding the &quot;why&quot; makes it much easier to pick up new tools later, because I’m not memorizing syntax — I’m recognizing a familiar problem wearing a different outfit.<br>2. Anchor every concept to a real problem.</strong></p><p><strong>Instead of learning statistics or Python in the abstract, I try to tie each new concept to a concrete business question: How would this help a company understand its customers? How would this improve a product? Concepts stick far better when they’re attached to a purpose.<br>3. Respect the hierarchy — don’t skip levels.<br>Based on the hierarchy of needs, I’m deliberately spending more time on data fundamentals — cleaning, structuring, and understanding data — before jumping into modeling. It’s less exciting, but it’s where most real-world data science time actually goes, so it’s worth building real competence here first.<br>4. Build small, complete projects instead of collecting tutorials.<br>Watching videos and reading articles feels productive, but it’s easy to mistake &quot;watching&quot; for &quot;learning.&quot; A better test is: can I take a small, messy dataset and produce a simple insight or report from it, start to finish, on my own? Small complete projects build real confidence and expose gaps that passive learning hides.<br>5. Get comfortable with being uncomfortable.<br>Data science involves a lot of not knowing — the right approach, the right tool, or even the right question. Progress often comes from sitting with that discomfort long enough to investigate, rather than jumping to the first tutorial that promises a shortcut.<br>6. Track what confuses you, and revisit it.<br>Keeping a running list of concepts that didn’t fully click has been useful. Revisiting them a week later — after more context has built up — usually makes them click much faster the second time around.<br>7. Separate &quot;interesting&quot; from &quot;important.&quot;<br>AI and deep learning are genuinely interesting, and it’s natural to be drawn to them. But recognizing that they represent a specialized slice of the field — not the daily reality for most data scientists — helps me prioritize learning what’s actually going to be useful day-to-day: data wrangling, analysis, and communicating findings clearly.</strong></p><p><strong>The reason this framework stuck with me is that it changes how I plan my own learning. If I had gone in assuming data science = machine learning, I would have rushed straight to algorithms and skipped the unglamorous — but essential — layers underneath: data collection, cleaning, exploration, and metrics. Those layers are the foundation everything else sits on. Skipping them is like trying to build the roof of a house before the walls exist.</strong></p><p><strong>It also reframes how I think about career paths. Not every data scientist needs to become a machine learning expert, and that’s fine. Plenty of impactful, well-paid, respected work in this field is analytics and metrics work — the &quot;boring middle&quot; that actually keeps companies running. Knowing this early helps me set realistic expectations instead of chasing a narrow, hyped version of the job.</strong></p><p><strong>Steps to Get Great Results While Learning Data Science<br>Learning a field this broad can get overwhelming fast, so here are the principles I’m using to stay focused and actually retain what I learn — not just move through material.<br>1. Learn the &quot;why&quot; before the &quot;how.&quot;<br>Before touching a tool or writing a line of code, I try to understand what problem it’s solving and why it exists. Tools change constantly; the underlying problems they solve usually don’t. Understanding the &quot;why&quot; makes it much easier to pick up new tools later, because I’m not memorizing syntax — I’m recognizing a familiar problem wearing a different outfit.<br>2. Anchor every concept to a real problem.<br>Instead of learning statistics or Python in the abstract, I try to tie each new concept to a concrete business question: How would this help a company understand its customers? How would this improve a product? Concepts stick far better when they’re attached to a purpose.<br>3. Respect the hierarchy — don’t skip levels.<br>Based on the hierarchy of needs, I’m deliberately spending more time on data fundamentals — cleaning, structuring, and understanding data — before jumping into modeling. It’s less exciting, but it’s where most real-world data science time actually goes, so it’s worth building real competence here first.<br>4. Build small, complete projects instead of collecting tutorials.<br>Watching videos and reading articles feels productive, but it’s easy to mistake &quot;watching&quot; for &quot;learning.&quot; A better test is: can I take a small, messy dataset and produce a simple insight or report from it, start to finish, on my own? Small complete projects build real confidence and expose gaps that passive learning hides.<br>5. Get comfortable with being uncomfortable.<br>Data science involves a lot of not knowing — the right approach, the right tool, or even the right question. Progress often comes from sitting with that discomfort long enough to investigate, rather than jumping to the first tutorial that promises a shortcut.<br>6. Track what confuses you, and revisit it.<br>Keeping a running list of concepts that didn’t fully click has been useful. Revisiting them a week later — after more context has built up — usually makes them click much faster the second time around.<br>7. Separate &quot;interesting&quot; from &quot;important.&quot;<br>AI and deep learning are genuinely interesting, and it’s natural to be drawn to them. But recognizing that they represent a specialized slice of the field — not the daily reality for most data scientists — helps me prioritize learning what’s actually going to be useful day-to-day: data wrangling, analysis, and communicating findings clearly.</strong></p><p><strong>Looking Ahead<br>I’m still right at the beginning, but I already feel like I have a clearer map of the terrain — what data science actually is, where the real work happens, and where the hype tends to live. My next steps are to build on this foundation with actual data work: cleaning, analysis, and the everyday tasks that make up most of the job.<br>This is just the start, but it feels like a solid one.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee4c667a85a7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>