<?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 Ege Oguz on Medium]]></title>
        <description><![CDATA[Stories by Ege Oguz on Medium]]></description>
        <link>https://medium.com/@iegeoguz?source=rss-7841ffde5098------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*syxUNfuJ7UNj7Z1c9A_gKA.jpeg</url>
            <title>Stories by Ege Oguz on Medium</title>
            <link>https://medium.com/@iegeoguz?source=rss-7841ffde5098------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 10:29:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@iegeoguz/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[Building a RAG-Powered Career Coach: Bridging the Gap Between Resume and Market]]></title>
            <link>https://medium.com/@iegeoguz/building-a-rag-powered-career-coach-bridging-the-gap-between-resume-and-market-bc5ec985c1f4?source=rss-7841ffde5098------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc5ec985c1f4</guid>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[fastapi]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[retrieval-augmented-gen]]></category>
            <category><![CDATA[nextjs]]></category>
            <dc:creator><![CDATA[Ege Oguz]]></dc:creator>
            <pubDate>Wed, 21 Jan 2026 17:02:19 GMT</pubDate>
            <atom:updated>2026-01-21T17:26:52.009Z</atom:updated>
            <content:encoded><![CDATA[<h4>Moving beyond generic LLM advice: A full-stack engineering approach to grounded career roadmaps.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Io1aB2XAWLrXQZZW-tflTw.png" /></figure><p>In the current tech landscape, career advice is abundant but often generic. Ask a standard Large Language Model for a study plan, and it will likely generate a convincing but potentially hallucinated roadmap. It might recommend deprecated libraries, non-existent courses, or generic paths that ignore a candidate’s existing background.</p><p>My latest project, AI Career Compass, addresses this precision gap. It is a full-stack platform designed specifically for Computer Science and Engineering professionals. Instead of relying solely on the creative capabilities of an LLM, I implemented a custom Retrieval-Augmented Generation pipeline. This ensures that every piece of career advice is grounded in verified technical resources, bridging the gap between unstructured candidate data and structured market requirements.</p><p>Here is the engineering story behind the architecture, the decision to use a local vector store, and how I solved the latency bottleneck common in RAG applications.</p><h3>Focused Engineering: The Experimental Scope</h3><p>This project was developed as a high-fidelity experiment to test the efficiency of RAG architectures in technical career counseling. To ensure a controlled testing environment, I intentionally focused the vector database on Computer Science and Engineering fundamentals.</p><p>By narrowing the knowledge base to a specific domain during the prototype phase, I was able to verify the model’s grounding and reasoning capabilities without the noise of unrelated industries. This specialized approach demonstrates how a modular RAG system can be verticalized for any professional field simply by swapping the underlying vector index.</p><h3>The Core Problem: Hallucination vs. Utility</h3><p>The primary challenge with using off-the-shelf LLMs for career planning is grounding. A junior developer needs specific, actionable resources (e.g., a specific documentation page or a verified tutorial), not just high-level concepts.</p><p>To solve this, I built the system around a curated knowledge base. When a user uploads their CV and states their career goal, the system doesn’t just hallucinate a path. It queries a local ChromaDB instance containing verified engineering resources. The LLM then acts as a reasoning engine, synthesizing the user’s gaps with the retrieved documents to create a personalized roadmap.</p><h3>The Strategic Value: Overcoming the Knowledge Cutoff</h3><p>Beyond minimizing hallucinations, this RAG architecture addresses a fundamental limitation of Large Language Models: the static training window.</p><p>Foundation models are frozen in time; an LLM trained in 2023 cannot inherently know about a JavaScript framework released last week. Fine-tuning a 70B parameter model for every new software update is computationally impractical.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1KY-SpOeRFovsjDNBfbhTg.png" /><figcaption><strong>Figure 1:</strong> Conceptual overview of the RAG advantage: Decoupling the reasoning engine from static training data to integrate real-time industry updates.</figcaption></figure><p>Although this specific implementation uses a curated local dataset to keep the scope manageable, the architecture proves a scalable solution to the freshness problem. By decoupling reasoning from knowledge , we create a system where updating the career advice is as simple as re-indexing a PDF. This approach allows the application to remain current with the fast-evolving tech market without ever touching the model’s weights.</p><h3>System Architecture</h3><p>The application follows a service-oriented architecture designed for separation of concerns and scalability.</p><p><strong>1. The Inference Engine (FastAPI &amp; Python)</strong> I chose Python and FastAPI for the backend to leverage the strong typing system and the rich ecosystem of AI libraries. The backend orchestrates the interaction between the user’s input, the vector database, and the inference API.</p><p><strong>2. The Reactive Frontend (Next.js)</strong> The user interface is built with Next.js using the App Router. Since generating a comprehensive career plan is a computationally expensive operation, the frontend focuses heavily on state preservation. I implemented a local storage synchronization strategy to ensure that if a user reloads the page during or after generation, the state is not lost, preventing unnecessary and costly re-generation of plans.</p><h3>The Engineering Challenge: Solving RAG Latency</h3><p>The most critical technical hurdle in this project was performance. A typical RAG workflow is sequential:</p><ol><li>Generate a plan step.</li><li>Search the database for resources for that step.</li><li>Generate the next step.</li><li>Repeat.</li></ol><p>For a 4-week learning roadmap, this sequential approach resulted in unacceptable wait times. The time-to-first-byte was fine, but the time to full completion was poor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UeUCy8XhGvXz6Aj3_zSYvw.png" /><figcaption><strong>Figure 2:</strong> The AI Career Compass interface generating a personalized roadmap based on verified resources.</figcaption></figure><p><strong>The Solution: Asynchronous Vector Search</strong> To optimize this, I decoupled the structural generation from the resource retrieval. The system first uses the LLM to draft the high-level skeleton of the learning path. Once the objectives are identified, the system utilizes Python’s asyncio and gather capabilities.</p><p>Instead of processing Week 1, waiting, and then processing Week 2, the engine dispatches vector search queries for<strong> </strong>all learning objectives across the entire timeline simultaneously.</p><p>This concurrent execution model allows the vector search, which is an I/O bound operation, to happen in parallel. In my benchmarks, this approach reduced the total request time for generating a multi-week plan by approximately 60% compared to the initial sequential prototype.</p><h3>Why Local Vector Store?</h3><p>In an era of managed cloud vector databases, I made the deliberate decision to use a local, persistent instance of ChromaDB combined with sentence-transformers for on-premise embedding generation.</p><p>This decision was driven by two factors:</p><ol><li><strong>Privacy:</strong> By processing embeddings locally, we minimize the amount of sensitive data sent to external APIs.</li><li><strong>Latency &amp; Cost:</strong> For this specific use case, the overhead of a network call to a managed vector store was unnecessary. Keeping the index local to the backend service ensures millisecond-level retrieval times without the recurring costs of cloud vector hosting</li></ol><h3>Conclusion</h3><p>AI Career Compass demonstrates that building an AI product is about more than just calling an OpenAI endpoint. It requires careful consideration of latency, data validity, and user experience. By implementing an async RAG pipeline and grounding the LLM in verified data, we can move from generic chat interfaces to actionable, professional-grade tools.</p><p><strong>Live Demo:</strong> <a href="https://www.aicareer-compass.com/onboarding">[Demo]</a></p><p><strong>Source Code:</strong> <a href="https://github.com/egeoguzz/ai-career-compass?tab=readme-ov-file#ai-career-compass">[Code]</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc5ec985c1f4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Heritage Paradox: Decoupling Energy Efficiency from Property Value in the UK Housing Market]]></title>
            <link>https://medium.com/@iegeoguz/the-heritage-paradox-decoupling-energy-efficiency-from-property-value-in-the-uk-housing-market-43c0f611b022?source=rss-7841ffde5098------2</link>
            <guid isPermaLink="false">https://medium.com/p/43c0f611b022</guid>
            <category><![CDATA[catboost]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[real-estate]]></category>
            <dc:creator><![CDATA[Ege Oguz]]></dc:creator>
            <pubDate>Tue, 20 Jan 2026 22:41:45 GMT</pubDate>
            <atom:updated>2026-01-20T22:44:30.864Z</atom:updated>
            <content:encoded><![CDATA[<h4>A data-driven investigation into the ‘Green Premium’ using Polars, Gradient Boosting, and Interpretable AI.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*in6e2eg-rqU_XL7tMRCY-g.png" /></figure><h3>The Heritage Paradox: Decoupling Energy Efficiency from Property Value in the UK Housing Market</h3><p>In data science, the most dangerous moment isn’t when your code fails, it’s when your model outputs a result that contradicts fundamental economic theory. Usually, this indicates a bug. But occasionally, it reveals a hidden market dynamic that no one else is talking about.</p><p>For this project, I set out to test the “Green Premium” hypothesis in the UK housing market, the idea that energy-efficient homes command higher prices. I built a robust pipeline merging millions of transaction records with energy performance certificates.</p><p>When I trained the model on London data, the results were baffling: higher energy efficiency correlated with lower prices. I assumed my pipeline was broken. To debug it, I ran the exact same architecture on Leeds as a control group. The model worked perfectly there, showing a clear linear relationship between efficiency and price.</p><p>This wasn’t a coding error. It was an economic anomaly I call “The Heritage Paradox.” Here is the engineering story behind how I used CatBoost, Polars, and SHAP to uncover it.</p><h3>1. The Architecture: Why CatBoost?</h3><p>Predicting house prices is a standard regression problem, but the UK housing dataset presents a specific challenge: high-cardinality categorical features. Variables like postcode_district (e.g., SW1, E14) and property_type are critical for valuation but are difficult for standard Gradient Boosting implementations to handle efficiently.</p><p>Traditional approaches like One-Hot Encoding would explode the dimensionality of the dataset, leading to sparse matrices and slow training times. I chose CatBoost specifically for its ability to handle categorical variables natively.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f35bzNV1jK9M-jxCPYmdcA.png" /><figcaption><strong>Figure 1: CatBoost Architecture.</strong> Unlike standard Gradient Boosting which requires One-Hot Encoding, CatBoost handles high-cardinality categorical features natively using Ordered Boosting and Symmetric Trees.</figcaption></figure><p>Instead of preprocessing these features externally, I passed the indices of categorical columns directly to the model. CatBoost uses Ordered Target Statistics to transform these categories into numerical values during training. This allowed the model to learn the hierarchical value of specific London postcodes without the need for massive, memory-intensive encoding steps.</p><h3>2. Data Engineering at Scale with Polars</h3><p>The analysis required merging two massive, disparate datasets:</p><ol><li><strong>HM Land Registry Price Paid Data:</strong> Transaction records for real estate sales (2018–2024).</li><li><strong>DLUHC EPC Certificates:</strong> Detailed energy performance metrics for domestic buildings.</li></ol><p>There was no common unique identifier between these datasets. Merging them required complex address reconciliation based on raw text strings a computationally expensive operation on millions of rows. Using Pandas for this would have resulted in memory bottlenecks. Instead, I utilized Polars, a Rust-based DataFrame library. By leveraging Polars’ LazyFrame API, I was able to define the entire cleaning, normalization, and merging logic as a computation graph. The execution was deferred until the collect() method was called, allowing the query optimizer to minimize memory usage. This reduced what would have been hours of processing time into minutes.</p><h3>3. Feature Engineering: Learning Inflation</h3><p>A major pitfall in real estate analysis is inflation. A property sold for £500k in 2018 is not equivalent to one sold for £500k in 2024.</p><p>A common approach is to adjust prices using a static CPI (Consumer Price Index) multiplier. I avoided this. Static multipliers assume inflation affects all asset classes equally, which is rarely true for real estate.</p><p>Instead, I injected temporal features (transaction_year, transaction_quarter) directly into the model. Gradient Boosting algorithms are excellent at detecting non-linear patterns. By providing the time data, I allowed the model to learn the specific inflation curve of the housing market itself.</p><p>Additionally, I engineered a price_per_sqm feature. Total price can be misleading; a small apartment in Chelsea costs more than a mansion in the suburbs. Normalizing by floor area provided the model with a granular signal of value density.</p><h3>4. Debugging with Economics: The Control Group Strategy</h3><p>After training the model on London data, I used SHAP values to interpret the feature importance. I expected to see a positive correlation between energy_rating_rank and price.</p><p>The SHAP dependence plot showed the opposite. In London, having a low energy rating (F or G) actually had a positive impact on the predicted price.</p><p>To rule out a pipeline error, I introduced a control group: Leeds. I hypothesized that a typical UK city, less distorted by extreme wealth and historical preservation than London, should follow standard economic rules.</p><p>I ran the exact same pipeline on Leeds data. The result? A textbook linear curve. In Leeds, moving from an ‘F’ rating to a ‘C’ rating consistently increased property value. This validated the code. The anomaly was in the market, not the machine.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qPnQy9dx_zH8dOkGpEJjCQ.png" /><figcaption><strong>Figure 2: The Tale of Two Cities.</strong> The left plot (Leeds) shows a standard Green Premium where higher energy ratings (x-axis) increase property value. The right plot (London) reveals the “Heritage Paradox,” where lower ratings often correlate with higher prices.</figcaption></figure><h3>Conclusion: The Heritage Paradox</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bpdj2ANKzP0Pi9peaXsqpQ.png" /><figcaption><strong>Figure 3: Global Feature Importance.</strong> In Leeds (left), high energy efficiency (red dots) pushes prices up. In London (right), high efficiency pushes prices down, showing that the market penalizes modern properties lacking historical character in prime areas.</figcaption></figure><p>The inverse correlation in London is not a glitch; it is a quantification of “Heritage Value.”</p><p>In London, the most desirable properties are often Victorian or Georgian terraced houses in prime locations (Kensington, Chelsea). These buildings are historically protected, difficult to insulate, and consequently have poor energy ratings. The model successfully identified that in this specific market, a low energy rating is often a proxy for a “period property,” which commands a massive premium over modern, energy-efficient, but characterless new builds.</p><p>By using interpretable AI tools like SHAP, we moved beyond simple prediction. We didn’t just ask what is the price?; we asked why?. This project highlights that in complex economic systems, model interpretability is just as critical as accuracy.</p><p><strong>Code &amp; Implementation:</strong> You can review the full pipeline and analysis in the repo below: <br>👉 <a href="https://github.com/egeoguzz/eco-valuate-uk"><em>Green Premium Analysis in the Uk</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43c0f611b022" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Case Study: Probabilistic Forecasting for the UK National Grid]]></title>
            <link>https://medium.com/@iegeoguz/case-study-probabilistic-forecasting-for-the-uk-national-grid-0ecc03a5e9a6?source=rss-7841ffde5098------2</link>
            <guid isPermaLink="false">https://medium.com/p/0ecc03a5e9a6</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[energy]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[time-series-forecasting]]></category>
            <dc:creator><![CDATA[Ege Oguz]]></dc:creator>
            <pubDate>Mon, 19 Jan 2026 22:15:12 GMT</pubDate>
            <atom:updated>2026-01-19T22:15:12.981Z</atom:updated>
            <content:encoded><![CDATA[<h4>Why I ditched standard LSTMs for Google’s Temporal Fusion Transformer (TFT) to handle renewable energy volatility.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xN_CMkqLhybe1GMpwsCNGQ.png" /></figure><p>In the realm of energy forecasting, accuracy is a matter of grid stability. My latest project focused on a specific challenge facing the UK National Grid: How do we forecast demand when renewable generation makes the grid increasingly non-linear?</p><p>Traditional statistical models and even standard Deep Learning models often fail here because they struggle with interpretability. They give a number, but they don’t tell you why.</p><p>For this experiment, I implemented Google Research’s Temporal Fusion Transformer. Here is the engineering logic behind why I chose this architecture and how it performed.</p><h3>The Core Problem: The Cost of Error is Asymmetric</h3><p>Most basic tutorials teach you to predict a single value. In production grid management, this is dangerous because the cost of error is asymmetric:</p><ul><li><strong>Over-predicting:</strong> You spin up expensive backup generators unnecessarily.</li><li><strong>Under-predicting:</strong> You risk frequency drops or blackouts.</li></ul><p>I needed a model that could quantify uncertainty. I didn’t want a single line, I wanted a risk profile.</p><h3>The Solution: TFT &amp; Quantile Loss</h3><p>I chose the TFT architecture because it natively handles heterogeneity in data. Unlike standard Transformers, it uses Gated Residual Networks to filter out unnecessary features before they even reach the attention mechanism.</p><ol><li><strong>Static Covariates:</strong> Things that don’t change.</li><li><strong>Known Future Inputs:</strong> Time of day, day of week.</li><li><strong>Observed Inputs:</strong> Historical load and generation data.</li></ol><p>Instead of minimizing Mean Squared Error, I optimized for Quantile Loss. The model outputs three distinct predictions for every time step:</p><ul><li><strong>P10 (Optimistic):</strong> The lower bound.</li><li><strong>P50 (Median):</strong> The most likely scenario.</li><li><strong>P90 (Pessimistic):</strong> The upper bound.</li></ul><p>This creates a confidence interval, essentially telling the grid operator: The demand will likely be X, but prepare for it to be as high as Y.</p><h3>Data Engineering: The Hidden Challenge</h3><p>Before feeding the model, the real engineering work was in the temporal alignment. UK Grid data often contains missing intervals or drift.</p><p>I implemented a robust preprocessing pipeline:</p><ul><li><strong>Interpolation:</strong> Missing values were filled via linear interpolation to maintain time-series continuity.</li><li><strong>Cyclical Encoding:</strong> Time variables were encoded as Sine/Cosine pairs. This is critical for the model to understand that “Hour 23” is mathematically close to “Hour 0”, preserving the daily cycle logic.</li></ul><h3>Experimental Setup: The “Ex-Post” Decision</h3><p>In my repository, you might notice I treated historical Wind and Solar data as known inputs for the future horizon.</p><p><strong>Why did I do this?</strong> In a live production environment, we would use Numerical Weather Prediction feeds. However, for this study, I intentionally used actual generation data.</p><ul><li><strong>The Engineering Goal:</strong> I wanted to isolate the model’s ability to learn the correlation between renewables and demand, without the noise of weather forecast errors. This proves the architecture works before introducing external data noise.</li></ul><h3>Results: The “Glass Box”</h3><p>The model successfully converged, capturing both daily seasonality and intra-day volatility driven by renewables. The power of probabilistic forecasting is visible below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*09qLYKJ_LUDsX9pT3k3sJg.png" /><figcaption><strong>Figure 1:</strong> Probabilistic forecast on test data. The orange line is the P50 prediction, and the shaded area represents the P10-P90 confidence interval. The blue line is the actual observed demand.</figcaption></figure><p>But the biggest win wasn’t just the accuracy; it was the interpretability. TFT’s Variable Selection Network allowed me to rank feature importance to understand <em>why</em> the model made those predictions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_4jvT4o2bLpxItwcGgYVFA.png" /><figcaption>Figure 2: Feature importance ranking derived from the model’s attention mechanisms. Wind Generation is the dominant historical driver.</figcaption></figure><p>The model autonomously learned the physics of the grid:</p><ul><li><strong>Encoder (History):</strong> While past demand (ND) is naturally the primary reference, Wind and Solar Generation were identified as the most significant environmental drivers. The model learned that historical fluctuations in renewables directly correlate with future demand shifts.</li><li><strong>Decoder (Future):</strong> Hour of Day is the dominant predictor for the future horizon, accounting for over 70% of importance in short-term steps.</li></ul><p>This confirms the model isn’t just memorizing patterns; it’s learning the causal relationship between renewable availability and human consumption.</p><h3>Conclusion</h3><p>Working with the Temporal Fusion Transformer highlighted a shift in modern AI: it is no longer enough to just fit a model; we must understand its internal attention and gate mechanisms. Mastering advanced architectures like TFT requires moving beyond simple regression and embracing probabilistic thinking. In a world where black-box models are increasingly scrutinized, the ability to build high-performance systems that are also transparent is the most valuable skill an engineer can possess.</p><p>For engineers working on critical infrastructure, interpretability is non-negotiable. While TFT is computationally heavier than simpler RNNs, the ability to explain why a forecast was made and to visualize the uncertainty via Quantiles makes it the superior choice for modern grids.</p><p><strong>Code &amp; Implementation:</strong> You can review the full PyTorch Forecasting implementation and the data pipeline in the repo below:</p><p>👉 <a href="https://github.com/egeoguzz/uk-grid-tft-forecasting"><strong>[GitHub: UK National Grid Demand Forecasting]</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0ecc03a5e9a6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RNN vs. Transformer: Why Parallelization Won the AI Race]]></title>
            <link>https://medium.com/@iegeoguz/rnn-vs-transformer-why-parallelization-won-the-ai-race-8b8077919828?source=rss-7841ffde5098------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b8077919828</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[neural-networks]]></category>
            <category><![CDATA[nlp]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Ege Oguz]]></dc:creator>
            <pubDate>Sun, 18 Jan 2026 17:28:58 GMT</pubDate>
            <atom:updated>2026-01-18T17:28:58.572Z</atom:updated>
            <content:encoded><![CDATA[<h4>From sequential bottlenecks to O(1) scaling: An engineering perspective.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BnAhdfeHFhDp4Fi1mf1pBw.png" /></figure><p>For decades, we treated language processing as a time-series problem. It made intuitive sense: humans read left-to-right, so our models should too. This was the era of Recurrent Neural Networks and LSTMs. They were brilliant at the time, but they carried a fatal architectural flaw that no amount of optimization could fix: Sequential Dependency.</p><p>To process the 10th word in a sentence, an RNN had to finish processing the 9th. This sequential chain meant that you couldn’t simply throw more compute at the problem to make it faster. We were trying to scale intelligence on hardware designed for parallel processing, using software designed for serial execution.</p><h3>Latency and Vanishing Gradients</h3><p>The fundamental problem with RNNs isn’t just their speed; it’s their inability to maintain signal integrity over long distances.</p><p>In an RNN architecture, the hidden state hₜ is a function of the previous state hₜ₋₁ and the current input xₜ:</p><blockquote><strong><em>hₜ = f(hₜ₋₁, xₜ)</em></strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*b-HfkEbrcO1BDu9UOkjxWA.png" /><figcaption><strong>Figure 1:</strong> The unrolled structure of an RNN. Notice how the computation of state H3 is physically blocked until H2 is complete. This is the visual definition of sequential latency.</figcaption></figure><p>This simple equation creates two massive engineering problems:</p><ol><li><strong>No Parallelization:</strong> You cannot calculate step 100 before step 99 is done. Modern GPUs spend most of their time waiting for the previous step to finish instead of crunching numbers.</li><li><strong>Vanishing Gradients:</strong> During backpropagation, gradients must travel back through time. When you multiply small gradients hundreds of times over a long sequence, they shrink towards zero. The model effectively “forgets” the beginning of the sentence by the time it reaches the end. It’s like a game of telephone; the context degrades with every step.</li></ol><h3><strong>“Attention Is All You Need”</strong></h3><p>In 2017, the paper <em>Attention Is All You Need</em> proposed a radical shift. It argued that recurrence wasn’t just unnecessary; it was holding us back.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*423RM5KAKVbFg9CReOmhgA.png" /><figcaption><strong>Figure 2:</strong> The original Transformer architecture. Note the absence of recurrent loops; data flows vertically through Attention and Feed-Forward blocks, enabling parallel processing.</figcaption></figure><p>The Transformer architecture, as visualized above, discarded the loop entirely. If you look closely at Figure 2, you won’t see arrows connecting time steps horizontally. Instead of passing a hidden state step-by-step, it uses a Self-Attention Mechanism to process the entire sequence simultaneously in a vertical stack.</p><p>In engineering terms, this shifted the paradigm from Maintenance of State to Global Relation Modeling. The model doesn’t need to “remember” the beginning of the paragraph by carrying a degrading signal; it simply “attends” to it directly.</p><h3>The LSTM Trap: Better Memory, Same Speed Limit</h3><p>Before the industry fully embraced the “Attention-only” approach shown above, LSTMs were the peak of the RNN era. They tried to fix the memory problem not by looking at the whole sequence, but by introducing complex gating mechanisms.</p><p>And they worked, technically. They allowed models to “remember” context over longer sequences than vanilla RNNs. However, when compared to the Transformer’s architecture, the flaw becomes obvious:</p><ul><li><strong>Attention vs. Gating:</strong> While the Transformer uses Attention to access any part of the sequence instantly, LSTMs tried to preserve context by carefully passing a “hidden state” bucket from step to step.</li><li><strong>The Compute Problem:</strong> LSTMs solved the <em>Signal</em> problem, but failed the <em>Compute</em> problem. Each cell required four distinct matrix multiplications, and critically, the sequential lock remained.</li></ul><p>The 100th token still had to wait for the 99th. This inability to parallelize is exactly what led to the architectural shift we see in the next section: the move to O(1) paths.</p><h3>Why Transformer Won: The O(1) Path</h3><p>The victory of the Transformer over the RNN is a victory of hardware-software fit.</p><ul><li><strong>RNN Approach:</strong> O(N) sequential operations. You are limited by the clock speed of a single core because step 5 waits for step 4.</li><li><strong>Transformer Approach:</strong> O(1) sequential operations. Since the computation for any token doesn’t depend on the previous token’s completion, the model can ingest an entire document at once.</li></ul><p>This parallelization allowed us to fully saturate the massive CUDA core counts of modern GPUs. It is the primary reason we moved from 300M parameter models to 1T+ parameter models. The architecture finally stopped fighting the hardware.</p><h3>The Trade-off: Memory Complexity</h3><p>Engineering is about trade-offs. While Transformers solved the sequential bottleneck, they introduced a memory bottleneck. The attention mechanism requires comparing every token to every other token, resulting in quadratic complexity O(N²).</p><p>This is why “context window” is the new scarcity. However, the industry made a collective decision: we will pay the price in VRAM to gain the benefit of infinite context scaling and parallel training.</p><h3>Conclusion</h3><p>RNNs didn’t die because they failed to model language; they died because they failed to scale. In the era of massive compute, the architecture that parallelizes best, wins. The Transformer isn’t just a smarter model; it’s a more efficient consumer of silicon.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b8077919828" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Breaking the 1B Parameter Barrier: Engineering Reliable On-Device Agents with Neuro-Symbolic AI]]></title>
            <link>https://medium.com/@iegeoguz/breaking-the-1b-parameter-barrier-engineering-reliable-on-device-agents-with-neuro-symbolic-ai-fb2c2e119e8b?source=rss-7841ffde5098------2</link>
            <guid isPermaLink="false">https://medium.com/p/fb2c2e119e8b</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <dc:creator><![CDATA[Ege Oguz]]></dc:creator>
            <pubDate>Sat, 17 Jan 2026 17:00:00 GMT</pubDate>
            <atom:updated>2026-01-17T17:10:58.034Z</atom:updated>
            <content:encoded><![CDATA[<h4>How I solved the “Reasoning Gap” in small language models using Swift, MLX, and deterministic guardrails.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HPfyDge0jCPkLJfAxOHIPA.png" /></figure><h3><strong>The Next Frontier is “Small”</strong></h3><p>While the world is fixated on the ever-growing parameter counts of models like GPT or Gemini, a quieter but equally significant revolution is happening at the edge. The future of AI isn’t just about how smart a model is in the cloud; it’s about how useful it can be in your pocket, offline, private, and efficient.</p><p>However, scaling down comes with a cost. In my recent project, building a privacy-first iOS agenda agent, I encountered the harsh reality of Small Language Models: they are fast, but they often lack the reasoning depth required for reliable task execution.</p><p>This post details my journey of optimizing a 1B parameter model to perform complex scheduling tasks on an iPhone, proving that with the right architecture, small models can punch well above their weight.</p><h3><strong>The Challenge: Mobile Constraints vs. Intelligence</strong></h3><p>My objective was simple in theory but complex in execution: Build an offline iOS agent that can read the user’s local calendar and summarize their schedule via a natural language interface.</p><p>The constraints were strict:</p><ul><li><strong>Zero Data Leakage:</strong> No cloud APIs. Everything must run on-device.</li><li><strong>Low Latency:</strong> The user cannot wait 10 seconds for a response.</li><li><strong>Memory Efficiency:</strong> The app must coexist with the OS, avoiding Out of Memory crashes.</li></ul><h4><strong>Iteration 1: The Size Problem (Microsoft Phi-3)</strong></h4><p>I began development with Microsoft’s Phi-3 Mini (3.8B). On paper, it’s a reasoning powerhouse. In practice, deploying it on a mobile device revealed immediate bottlenecks.</p><p>The model’s binary size exceeded 2.3GB. For a utility app, this is unacceptable storage overhead. More critically, the inference latency on the iPhone’s Neural Engine hovered around 3–4 tokens per second. While the output quality was high, the user experience was sluggish and the device thermal throttled within minutes of sustained usage.</p><h4><strong>Iteration 2: The Reasoning Gap (Qwen &amp; Llama 3.2)</strong></h4><p>To solve the latency issue, I pivoted to the sub-2B parameter class, testing Qwen 2.5 and eventually settling on Meta’s Llama 3.2 1B (4-bit quantized).</p><p>Moving to a 1B model solved the speed and storage issues immediately. The model size dropped to under 700MB, and inference speed tripled. However, this introduced a new problem: Hallucination<strong>.</strong></p><p>When asked, “What am I doing next?” vs. “What does my week look like?”, the 1B model frequently failed to distinguish the temporal context. It would hallucinate meetings that didn’t exist or summarize the wrong dates. It became clear that while 1B models are excellent at fluency, they suffer from a Reasoning Gap when handling strict logic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/943/1*7MXTA3hK38euIVP18UMTyw.jpeg" /><figcaption>Figure 1: Example of Reasoning Gap.</figcaption></figure><h4><strong>The Solution: A Hybrid Neuro-Symbolic Architecture</strong></h4><p>Instead of trying to fine-tune the model to be smarter (which is difficult on-device), I changed the system architecture. I adopted a Neuro-Symbolic approach, treating the LLM not as the Brain, but as the Interface.</p><p>I implemented a deterministic logic layer in Swift using Apple’s EventKit and MLX framework. Here is how the pipeline works:</p><ol><li><strong>Intent Classification (O(1)):</strong> Before invoking the expensive LLM, a lightweight Swift classifier detects if the user is asking a temporal question (e.g., “tomorrow”, “next event”).</li><li><strong>Logic Offloading:</strong> If a temporal intent is detected, the app programmatically fetches and filters the exact calendar data.</li><li><strong>System Injection:</strong> The ground truth is injected into the system prompt with strict constraints.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fBJ3BwI0Pb35df9YqcHDDw.png" /><figcaption>Figure 2: The Hybrid Neuro-Symbolic Logic Flow</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HsOEYzyDLc334yVzJaR0Qg.jpeg" /><figcaption>Figure 3: <em>Deterministic Intent Classification Layer</em></figcaption></figure><p>You might notice the logic is deliberately simple using string matching. This is a strategic choice. While a secondary ML model (like BERT) could classify intents with higher flexibility (catching typos like ‘nxt’), it would introduce distinct latency. For this 1B-model experiment, I prioritized speed, proving that raw Swift logic can outperform neural networks in specific, rigid tasks</p><p>This Pre-Computed Responsestrategy effectively downgrades the LLM’s role. It is no longer responsible for <em>finding</em> the answer, only for formatting it.</p><h4><strong>Results: Deterministic Accuracy</strong></h4><p>By shifting the logical load from the neural network to the symbolic code, the agent achieved 100% factual accuracy on scheduling tasks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/943/1*SLrAlfEy0xZdh0TQMvERwA.jpeg" /><figcaption>Figure 4: Sample Output.</figcaption></figure><p>The final implementation utilizes 4-bit quantization to keep the memory footprint under 2GB, ensuring the app runs smoothly even on older devices without triggering iOS memory pressure terminations.</p><h4><strong>Conclusion: The Case for Task-Specific SLMs</strong></h4><p>The hype cycle will continue to push for larger models, but the engineering reality points towards specialization. We don’t need a 70B parameter model to tell us our schedule; we need a 1B model wrapped in a robust, deterministic architecture.</p><p>For developers looking to build the next generation of privacy-focused apps, the key isn’t just prompt engineering, it’s system engineering. Combining the probabilistic power of LLMs with the deterministic reliability of code is the only way to build software that is both magical and reliable.</p><p>— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —</p><p>The full implementation, including the hybrid Swift-MLX engine and the 4-bit quantization setup, is open-source. You can inspect the architecture, contribute, or fork the repository here:</p><p>👉 <a href="https://github.com/egeoguzz/local-intelligence"><strong>[GitHub Repository: LocalMind — iOS Neuro-Symbolic Agent]</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fb2c2e119e8b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Renaissance of Code: Why 2026 is the Golden Age to Study Computer Science]]></title>
            <link>https://medium.com/@iegeoguz/the-renaissance-of-code-why-2026-is-the-golden-age-to-study-computer-science-308b4c85f6a5?source=rss-7841ffde5098------2</link>
            <guid isPermaLink="false">https://medium.com/p/308b4c85f6a5</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[future]]></category>
            <category><![CDATA[humanity]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Ege Oguz]]></dc:creator>
            <pubDate>Fri, 21 Nov 2025 21:08:20 GMT</pubDate>
            <atom:updated>2025-11-21T21:08:43.742Z</atom:updated>
            <content:encoded><![CDATA[<h4>Don’t let the AI doom-mongering fool you. The era of “coders” is ending, but the era of “architects” is just beginning.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3VpyF6ISGrbuWs8xsYzDiA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@david_underland">David Underland</a> on Unsplash.</figcaption></figure><p>As we step into 2026, a shadow of uncertainty looms over Computer Science departments worldwide. A prevailing narrative suggests that pursuing a Bachelor’s or Master’s in CS today is a career suicide, a ticket to a field destined to be cannibalized by Artificial Intelligence.</p><p>This is not just a misconception; it is a fundamental misunderstanding of what software engineering actually is. Buying into the hype that “AI will replace developers” is dangerous. It overlooks a massive opportunity.</p><p>Here is why 2025 isn’t the end of the road for CS graduates, it is the beginning of a new, limitless frontier.</p><h3>1. The “Replacement” Fallacy</h3><p>We see AI generating art, automating Excel tasks, and composing music. As robotics advance, we might soon see AI replacing physical labor too. Yet, paradoxically, the panic seems disproportionately focused on software developers.</p><p>This perspective is flawed. Software engineering has never been about stability or repetition. Unlike industries that fear disruption, CS is <em>built</em> on it. Even before the AI boom, an iOS developer could see their entire workflow vanish with a single SwiftUI update. We are accustomed to the ground shifting beneath our feet.</p><p>The motivation for a true engineer has never been “doing the same thing every day for a comfortable life.” It has always been about problem-solving in a chaotic environment.</p><h3>2. From Stagnation to the Blue Ocean</h3><p>Looking back at the last decade (the Web 2.0 era), it felt like the “low-hanging fruit” had already been picked. Platforms like Facebook or Instagram, while revolutionary, were conceptually linear. For a long time, it felt like we reached a saturation point; there were no earth-shattering apps breaking the mold. We were optimizing, not inventing.</p><p>An aspiring computer scientist today isn’t entering a saturated market; they are standing at the edge of a new era. We are no longer limited by what we can type; we are limited only by what we can imagine. AI is not a wall; it is a force multiplier. It allows students to learn faster, build complex systems alone, and swim in an ocean of infinite possibilities.</p><p>Vilifying the very technology that we design is counter-intuitive. We should not fear the tool; we should master it.</p><h3>3. The “Coder” vs. The “Engineer”</h3><p>Let’s address the elephant in the room: <strong>Writing code is becoming a commodity. </strong>With the release of next-gen LLMs (like GPT-4o and Gemini 1.5), we have witnessed AI writing syntactically perfect code in seconds. If your definition of a developer is “someone who translates requirements into syntax,” then yes, your job is in danger.</p><p>However, <strong>Software Engineering</strong> is one of the hardest professions to automate. Why? Because real-world engineering is rarely about following a perfect pattern.</p><p>If you work outside of Big Tech, and let’s be honest, most software is built in the messy reality of non-tech enterprises, you know that the job involves navigating chaos. It involves:</p><ul><li>Making strategic trade-offs for stakeholders.</li><li>Navigating ambiguous requirements that no LLM can fully parse.</li><li>Implementing “ugly” fixes because business deadlines demand them.</li></ul><p>This is why Agile methodologies exist. Software development is human-centric, messy, and requires high-level judgment. AI can generate a function, but it cannot negotiate a feature reduction with a product manager or decide when to incur technical debt for speed.</p><h3>4. The Verdict: Adapt or Perish</h3><p>My prediction for the next 5 years is clear:<br><strong>AI will not replace software engineers. Software engineers who use AI will replace those who don’t.</strong></p><p>The efficiency gains from AI will separate the wheat from the chaff.</p><ul><li><strong>The “Typists”:</strong> Those who hide behind a desk, waiting for a ticket to translate into code, are in trouble.</li><li><strong>The “Architects”:</strong> Those who view AI as a junior pair programmer, allowing them to focus on system design, architecture, and solving complex human problems, will become more powerful than ever.</li></ul><p>2026 is the best time to study Computer Science because the barrier to <em>entry</em> (syntax) has lowered, but the ceiling for <em>impact</em> has shattered. Don’t fear the new technology. History shows that those who approach innovation with fear get left behind, while those who embrace it build the future.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=308b4c85f6a5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3 Simple Tips to Write Faster C++ Code]]></title>
            <link>https://medium.com/@iegeoguz/3-simple-tips-to-write-faster-c-code-e039a49051f5?source=rss-7841ffde5098------2</link>
            <guid isPermaLink="false">https://medium.com/p/e039a49051f5</guid>
            <category><![CDATA[software]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cpp-programming]]></category>
            <category><![CDATA[cpp]]></category>
            <dc:creator><![CDATA[Ege Oguz]]></dc:creator>
            <pubDate>Sun, 13 Jul 2025 20:43:33 GMT</pubDate>
            <atom:updated>2025-07-13T20:43:33.996Z</atom:updated>
            <content:encoded><![CDATA[<h4>Small changes in your daily coding habits can lead to big performance improvements in C++.</h4><h3>Introduction</h3><p>C++ is famous for performance. But writing faster code doesn’t always require deep profiling or complicated tricks.<br> Sometimes, small habits lead to big improvements.</p><p>Here are <strong>3 simple and effective tips</strong> I use all the time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aYE3I0reZHF5Bt_N3Ja_6w.png" /></figure><h3>1) Use const Everywhere You Can</h3><p>The more you use const, the more optimizations the compiler can do.<br> Also, it makes your code easier to understand for others (and your future self).</p><pre>void printName(const std::string&amp; name) {<br>    std::cout &lt;&lt; name &lt;&lt; std::endl;<br>}</pre><p><strong>Why?</strong><br> Avoids unnecessary copies, keeps things clean.</p><h3>2) std::move and emplace Are Your Friends</h3><p>Copying in C++ is expensive. Learn to use move and emplace whenever possible.</p><pre>std::vector&lt;std::string&gt; names;<br>names.emplace_back(&quot;Ege&quot;);</pre><p><strong>Why?</strong><br> No copies, no extra constructors.</p><h3>3) Small Functions, Cleaner Code</h3><p>Big functions are harder to read and harder to optimize. Write small, clear functions.</p><pre>void handleUser() {<br>    getUserData();<br>    processUser();<br>    saveUser();<br>}</pre><p><strong>Why?</strong><br> Helps with cache, branch prediction, maintenance.</p><h3>Conclusion</h3><p>C++ is already fast. Sometimes, writing faster code is simply about better habits.</p><p>What are your favorite C++ performance tips? Let me know in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e039a49051f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why You Should Still Learn C++ in 2025]]></title>
            <link>https://medium.com/@iegeoguz/why-you-should-still-learn-c-in-2025-2ce6c255929c?source=rss-7841ffde5098------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ce6c255929c</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[cpp-programming]]></category>
            <category><![CDATA[high-performace-computing]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Ege Oguz]]></dc:creator>
            <pubDate>Sun, 06 Jul 2025 20:23:13 GMT</pubDate>
            <atom:updated>2025-11-21T21:11:39.724Z</atom:updated>
            <content:encoded><![CDATA[<h4>From AI to system programming, C++ offers unmatched performance, control, and learning opportunities.</h4><p>In my new series, I’ll be covering topics related to C++. After that, we’ll dive into technical articles about AI. But before we start all of that, I want to explain why C++ is still so important today.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2kPC6zO5j23DZgyOcsBLFw.jpeg" /><figcaption>Photo by Uday Awal on <a href="https://unsplash.com/">Unsplash</a></figcaption></figure><h3>1. Performance is Always in Style</h3><p>Some of you might think C++ is outdated but that couldn’t be further from the truth. C++ remains one of the most powerful programming languages in terms of raw performance. Thanks to features like pointers and low-level memory control, it gives developers significant authority over how their programs operate.</p><p>Especially for those who are new to programming but want to build a strong foundation, I highly recommend starting with C++. What sets great developers apart from the rest is not just writing code, but writing <em>efficient</em> code. By 2025, almost anyone can code. But understanding how to write high-performance code, that’s what makes you stand out.</p><p>And performance isn’t just about traditional software. Even in AI and machine learning, performance is everything. From optimizing GPU workloads to improving inference times, your ability to write efficient code directly impacts the results and C++ is a perfect tool for this.</p><p>Writing high-performance code requires both a language that allows for control and an understanding of what’s happening under the hood. For example, knowing how a simple swap operation works, or understanding how a PyTorch function utilizes GPU resources, gives you a huge advantage in real-world applications.</p><p>No matter the era or the technology, even in AI-dominated fields, performance will <em>always</em> be a key metric.</p><p>And the first step to mastering performance is using a language that teaches you how. That’s where C++ shines. It’s like medicine for your programming foundation.</p><h3>2. Modern C++ is Not What You Think</h3><p>Despite being labeled as outdated by some, C++ continues to evolve as a programming language. In fact, many people are surprised when I tell them that <strong>C++23</strong> was released in 2023 and is actively used in 2024 and beyond.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/1*bvf0ZSwmcFDDL18hCWN0rw.png" /><figcaption>Source: <a href="https://en.wikipedia.org/wiki/C%2B%2B">C++ Wikipedia Page</a>, image licensed under Creative Commons.</figcaption></figure><p>C++ is not just limited to system-level programming. If you take a closer look at prestigious universities like <strong>TUM</strong>, where I’m doing my master’s, you’ll often find that professors working in AI also rely on C++. Why? Because when it comes to writing efficient, high-performance code, few languages can compete with C++.</p><p>Moreover, by using C++, researchers can design their own systems from scratch and modify theoretical models at a low level, providing flexibility that other languages often lack.</p><p>Recent versions of C++ have introduced many advanced features, making the language more modern, readable, and powerful than ever before. Features like smart pointers, lambdas, concepts, and modules significantly improve both code quality and developer experience.</p><h3>3. Low-Level Control: You Can’t Find This Anywhere Else</h3><p>Once you start writing C++, you’ll quickly realize, often without even trying, that you’re gaining control over memory management, hardware-level behavior, and the runtime environment. Your understanding of how programs interact with hardware will naturally improve.</p><p>Even if you’re not consciously focusing on these areas, you’ll develop these skills while debugging runtime errors or designing your own systems and data structures. This hands-on exposure is one of the reasons why C++ remains invaluable for anyone who wants to truly understand how computers work under the hood.</p><p>No other mainstream programming language gives you this level of low-level control while still providing the tools to build complex, high-performance applications.</p><h3>4. Industry Demand is Still Strong</h3><p>If you take a closer look at salary reports and job listings, you’ll see that C++ is far from being obsolete. In fact, C++ skills are still highly valued and often lead to higher salary offers, especially for specialized positions.</p><p>Today, C++ may appear to be a “niche” language — but that perception exists not because the demand is low, but because languages like Python and JavaScript have become extremely popular in the mainstream developer community.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tyMZgxeRpBpZTkTKEwC51w.png" /><figcaption>Source: <a href="https://www.phaedrasolutions.com/blog/highest-paying-programming-languages">Phaedra Solutions — 15 Highest Paying Programming Languages</a></figcaption></figure><p>However, C++ maintains a broad range of use cases, spanning industries such as:</p><ul><li>Game development</li><li>Artificial intelligence and machine learning</li><li>Financial software and quantitative trading</li><li>Embedded systems and IoT devices</li><li>High-performance computing and simulation</li></ul><p>C++ remains an essential skill for anyone aiming to work on complex, performance-critical systems where efficiency truly matters.</p><h3>5. Challenging for Beginners, But Massively Rewarding</h3><p>I completely agree starting with C++ requires at least three times more effort than starting with a beginner-friendly language like Python.</p><p>But here’s the good news: That extra effort pays off. By learning C++, you’ll gain a much deeper understanding of core programming concepts, system behavior, and the philosophy behind software development itself, much more than someone who only learns to code with Python.</p><p>In a world where even AI can generate code, one of the few things that will truly differentiate developers, especially those who want to grow and master their craft, is this deep understanding.</p><p>Because even if you’re training AI models, you’re still relying on these core theoretical principles to guide that process. The better you understand them, the better your models and systems will perform.</p><h3>Conclusion: You’re Not Too Late to Start!</h3><p>C++ is still, in my opinion, one of the best choices in 2025 whether you’re just starting to code or already familiar with other languages but want to level up your programming skills.</p><p>Compared to C, C++ is easier to work with while offering the same (or even greater) level of power and control. And for those who know a bit of coding history, the name “C++” itself reflects this idea, it’s essentially shorthand for “C = C + 1,” symbolizing an evolution of the C language.</p><p>For developers who already know how to code, I highly recommend exploring C++-specific concepts and practicing on platforms like LeetCode. This will significantly boost your algorithmic thinking and overall coding ability.</p><p>One of C++’s greatest strengths is the control and flexibility it offers. With a deep understanding of C++, you can design custom data structures and performance-optimized solutions tailored specifically to the needs of your project, making it one of the most powerful tools in a developer’s arsenal.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ce6c255929c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Truth About AI in Mobile Apps and Why You Should Start Now]]></title>
            <link>https://medium.com/@iegeoguz/the-truth-about-ai-in-mobile-apps-and-why-you-should-start-now-e26c3daae818?source=rss-7841ffde5098------2</link>
            <guid isPermaLink="false">https://medium.com/p/e26c3daae818</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[apple-intelligence]]></category>
            <category><![CDATA[career-tips]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[mobile-development]]></category>
            <dc:creator><![CDATA[Ege Oguz]]></dc:creator>
            <pubDate>Sun, 29 Jun 2025 18:51:14 GMT</pubDate>
            <atom:updated>2025-11-21T21:14:39.787Z</atom:updated>
            <content:encoded><![CDATA[<h4>A beginner-friendly guide to adding AI features to your mobile apps, no complex theory required.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H60HsTeXKNnweusjA3AdYg.png" /></figure><h3>The Big AI Misconception</h3><p>From what I’ve observed in the software world, many developers who stay away from AI still believe it’s all about heavy math and complicated theories. I used to think the same the first time I heard terms like “neural networks” or “gradient descent,” I immediately pictured long nights of equations and coffee-fueled math marathons. Spoiler alert: You can actually skip most of that and still build smart, AI-powered apps. In my opinion, that’s one of the biggest misconceptions in our industry.</p><p>Especially in mobile development, we have access to an almost unlimited amount of user data, of course, within the boundaries of permissions and privacy rules. Yet, building mobile apps today without leveraging this power is like going to war with swords and shields while everyone else has drones.</p><p>The truth is, even with basic AI knowledge, you can dramatically improve the user experience, make your apps smarter, and create life-enhancing features. And no, you don’t need to be a math genius or spend years in an academic lab to get started.</p><h3>The Rise of AI in the Mobile World</h3><p>These days, it’s nearly impossible to download a popular app from the App Store or Google Play without seeing traces of AI inside. And in the startup world, one of the first questions that comes up is: <em>“How are you integrating AI into this project?”</em></p><p>I’ve personally experienced this mindset during my three years working at a startup.</p><p>The reality is, AI is no longer optional, it’s becoming a necessity. The real competitive edge comes from how effectively and seamlessly you can integrate AI into your product.</p><p>I remember when we developed an AI-powered API at my previous company and shared it with the mobile team working on the client side. Their initial reaction was distant, almost hesitant, as if AI was something mysterious. But from a technical standpoint, it wasn’t much different than consuming any other backend API.</p><p>This is exactly where basic AI knowledge becomes crucial for mobile developers. With tools like Apple’s Core ML, Google ML Kit, and similar frameworks, you don’t need to reinvent the wheel, AI capabilities are becoming accessible right from your IDE.</p><p>Looking ahead, I believe one of the biggest turning points will be Apple’s newly announced Apple Intelligence initiative. While Apple may have lagged behind in the AI race for a while, devices like iPhones are incredibly powerful when it comes to collecting data and running on-device AI processes. I believe they’ll close that gap fast, and with it, new doors will open for mobile developers. Especially for developers willing to experiment early, this means opportunities to build apps that leverage on-device AI features with minimal latency, enhanced privacy, and smarter user experiences, all powered by Apple’s ecosystem.</p><p>The best part? You don’t need a deep understanding of complex math to get started. It’s similar to how we rely on abstraction in everyday software development. We build apps without fully understanding low-level memory management or pointer operations, yet everything works.</p><p>Learning to integrate AI with existing libraries provides the same advantage, it opens up a massive playground where you can build smarter, more innovative mobile apps without drowning in theoretical details.</p><h3><strong>Why Mobile Developers Need Basic AI Knowledge</strong></h3><p>One of the biggest reasons is simple, almost every successful app today uses some form of AI.</p><p>As your career progresses and you step into senior or lead roles, understanding how AI works becomes essential. You need to manage teams, communicate with product stakeholders, and handle AI-related requests on the client side effectively.</p><p>Here’s the good news: you don’t need to be a data scientist. But having a solid grasp of the following makes a huge difference:</p><p>✅ How AI systems process and handle data</p><p>✅ The key differences between AI applications like chatbots, recommendation engines, or computer vision features</p><p>✅ Understanding how LLMs (Large Language Models) differ from traditional machine learning models. In simple terms, classic machine learning models are often trained for specific tasks with limited datasets think image recognition or spam filters. LLMs, on the other hand, are trained on massive amounts of data and designed to generate human-like language or solve broader, complex problems like answering questions or summarizing text.</p><p>This foundational knowledge allows you to not only write better code but also understand the bigger picture of how AI integrates into your product.</p><p>And it’s even more critical for freelancers or developers building their own products.</p><p>During my three years working at a US-based company, I noticed one recurring theme, investors always asked how efficiently AI was being used in the app.</p><p>Today, it’s not enough for your app to simply work; stakeholders, investors, and users expect it to be smart. That’s why mobile developers who ignore AI risk falling behind in an industry where innovation is everything.</p><h3>Where Should Mobile Developers Start with AI? (For Those Who Hate Math)</h3><p>If you feel distant from AI and the whole “heavy math” part scares you — totally normal. That’s exactly why many developers avoid diving into AI. But here’s the good news: You don’t need advanced math knowledge to get started with simple, practical AI projects.</p><p>My suggestion? Start with something small, pick a GPT model and build a mobile project where you collect user data, process it, and generate smart prompts dynamically. It’s a super hands-on way to get familiar with how AI works behind the scene, without drowning in theory.</p><p>Once you’ve done that, here are the next steps I recommend (zero scary math included):</p><p>✅ Using OpenAI API:<br> Forget complicated backends or giant systems. With simple API calls, you can bring powerful AI features into your mobile app. Think chatbots, AI-generated suggestions, smart interactions, and the documentation makes it pretty beginner-friendly.</p><p>✅ Deploying Models with Core ML:<br> If you’re an iOS developer, Apple’s Core ML lets you run pre-trained models directly on the device. No internet required for real-time AI features like image processing or sound recognition. Apple provides tools that simplify the whole process.</p><p>✅ Exploring ML Kit Examples:<br> For Android developers, Google’s ML Kit makes it super easy to add AI-powered features like face detection, barcode scanning, or text recognition. Most of it works with simple libraries, no deep theoretical knowledge required, just a few lines of code.</p><p>✅ Simple Projects with Hugging Face:<br> Hugging Face offers tons of open-source models you can quickly test, especially for text-based projects. It’s one of the most popular platforms in the AI community, known for making cutting-edge models accessible even for beginners, no complex setup, just clear examples and pre-trained options ready to go. It works for both mobile and backend use cases, and their beginner-friendly examples make it easy to experiment without needing a PhD.</p><p>Bottom line? Starting your AI journey as a mobile developer is way easier than you think. You can always dive deeper into the theory later if you want, but focusing on practical tools and small projects from day one builds your confidence, and your portfolio, fast.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l28gybeJekFKVCNruDPfVg.png" /></figure><h3>Final Thoughts — Don’t Fear AI, and AI Shouldn’t Fear You</h3><p>In this article, I shared my perspective as someone who’s been closely following the rise of AI, especially focusing on how mobile developers, even those who don’t have a strong AI background, can still be part of this transformation.</p><p>The truth is, people fear what they don’t understand, and AI is no exception. But once you take small steps, work on simple projects, and leverage existing tools, that fear starts to fade. And the more comfortable you get, the easier it becomes to dive deeper into advanced topics.</p><p>Personally, I’m constantly working on expanding my AI knowledge and trying to carve out my place in the world of AI-based Applications, a space that’s still evolving and full of unknowns, which makes it even more exciting.</p><p>I’ll be sharing more technical, advanced articles soon, so stay tuned. But fair warning… those might come with a little bit of math this time! :)</p><p>If you’re also exploring mobile development and AI, feel free to connect or share your experiences, I’d love to hear how others are navigating this exciting space.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e26c3daae818" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Will AI Replace Software Engineers? Here’s What No One Talks About]]></title>
            <link>https://medium.com/@iegeoguz/will-ai-replace-software-engineers-heres-what-no-one-talks-about-92cdc04360c1?source=rss-7841ffde5098------2</link>
            <guid isPermaLink="false">https://medium.com/p/92cdc04360c1</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Ege Oguz]]></dc:creator>
            <pubDate>Sun, 22 Jun 2025 19:58:04 GMT</pubDate>
            <atom:updated>2025-06-22T19:58:04.270Z</atom:updated>
            <content:encoded><![CDATA[<h4>A Young Engineer’s Perspective</h4><h3>Introduction</h3><p>These days, it feels like everyone’s talking about how AI will eventually take over most jobs. As a young engineer currently pursuing a master’s in AI, I wanted to share my thoughts on this. Which careers are actually safe? Should we all be worried about unemployment? Let’s dive into these questions with a focus on software engineering.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BSHWP2taRceSjWUi_UfqVw.png" /></figure><h3>The AI Hype vs. Reality</h3><p>Every new tech trend is hyped as “the next big thing,” but most eventually fade into the background, just like how electricity or the internet once felt like science fiction but now power everything quietly in the background.<br>So, will AI become just another passing trend, or is it really going to replace everything?</p><p>Right now, AI is already making many tasks significantly easier, and its capabilities are growing by the day. That’s exactly what’s scaring people: If AI keeps progressing at this rate, where will it be in 10–15 years? Will it really make certain jobs obsolete?</p><p>It’s natural to fear the unknown. But in reality, when we talk about “AI” today, we mostly mean <strong>large language models (LLMs)</strong>. LLMs are only one field of AI, and although they’re incredibly powerful, they have many limitations. Most importantly, an AI model is only as good as the data and human expertise it’s built upon.<br> Without real-world, high-quality data — often created by experts — these tools simply can’t function.</p><p>Still, just because AI needs data today doesn’t mean it will always need constant human involvement. In fact, with enough training, AI could start performing tasks that are currently done by people.<br> This is why there’s so much anxiety, especially among software engineers. It’s a strange dilemma: The very people building AI worry that AI might take their jobs.</p><h3>The Current Reality</h3><p>Right now, tools like ChatGPT and GitHub Copilot have already made writing code way easier. AI-driven autocomplete features inside IDEs make day-to-day coding much more efficient.<br> But is AI ready to fully replace a software engineer? Not quite yet.</p><p>What makes software engineering uniquely challenging — even compared to other branches of engineering — is its <strong>dynamic nature</strong> and the need for methodologies like Agile. One of the most important (and underestimated) aspects is <strong>requirements engineering</strong>.<br> Anyone who’s worked on real-world projects knows that requirements constantly change, evolve, or even get rewritten from scratch.<br> For me, this is the main reason AI won’t be able to fully replace software engineers anytime soon: Without ongoing human interaction and adaptation, building robust software is nearly impossible.</p><p>There are also hard technical limitations. LLMs can’t (yet) generate massive, production-ready codebases like “build me an aircraft autopilot software” in a single shot. Sure, these limitations might fade as technology advances, but the constant evolution of requirements is an even tougher nut to crack.</p><h3>Looking Ahead: Will AI Replace Us, or Transform Us?</h3><p>Software engineering is no longer just about knowing syntax — it’s about knowing what to build, why to build it, and how to build it better than others (including AI).</p><p>None of this means AI will never disrupt software engineering. In fact, we’re already seeing major changes. For engineers who know how to leverage AI tools, the job is already shifting — sometimes it feels like it’s 30% coding, 70% prompt engineering and problem framing — and this trend will only accelerate. Developers (and professionals in every field) who can best integrate AI into their workflow will be the ones who truly stand out.</p><p>So instead of resisting change, I believe it’s essential to at least understand the basics of how AI works, to improve our prompt engineering skills, and to become the people who can best integrate AI into our work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zyT58LEIl-i8kBCDdfYoLQ.png" /></figure><h3>Summary</h3><p>AI can absolutely help us work smarter and boost our productivity. But to stay relevant, excel in our fields, and even be among the highest earners, we need to understand how AI works and keep up with new developments.<br> From my own global experience, I can already see that those who embrace and integrate AI are starting to make a real difference.</p><p>We’re entering a golden era for those who know how to use AI as a tool, not just as a buzzword. Even if, someday, AI could do your entire job, there will always be a need for human expertise — to supervise, to prompt, to decide what needs to be done next.<br> Of course, this requires a willingness to keep learning, a bit of mathematical and technical curiosity, and a genuine interest in how AI systems really work.</p><p>To master any tool, you have to understand its inner workings.<br> It’s not always easy, but as the old saying goes:</p><blockquote>“If you want peace, prepare for war” — and in our case, that means mastering AI.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92cdc04360c1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>