<?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 Moises Meza on Medium]]></title>
        <description><![CDATA[Stories by Moises Meza on Medium]]></description>
        <link>https://medium.com/@moises.meza?source=rss-4a1f1f4dd7a8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Fki7iuiajjMp2yU9</url>
            <title>Stories by Moises Meza on Medium</title>
            <link>https://medium.com/@moises.meza?source=rss-4a1f1f4dd7a8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 21:26:02 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@moises.meza/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[From a Python-based web application to an installable desktop application with local ML inference…]]></title>
            <link>https://medium.com/@moises.meza/from-a-python-based-web-application-to-an-installable-desktop-application-with-local-ml-inference-6042a6fc1d9c?source=rss-4a1f1f4dd7a8------2</link>
            <guid isPermaLink="false">https://medium.com/p/6042a6fc1d9c</guid>
            <category><![CDATA[streamlit]]></category>
            <dc:creator><![CDATA[Moises Meza]]></dc:creator>
            <pubDate>Wed, 19 Aug 2026 20:19:36 GMT</pubDate>
            <atom:updated>2026-08-19T20:19:36.594Z</atom:updated>
            <content:encoded><![CDATA[<h3>From a Python-based web application to an installable desktop application with local ML inference and cloud-based computer vision</h3><h3>1. What we are going to build</h3><p>The tutorial can introduce a small application with this architecture:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oH695tfAxCA9AlLyIbysrw.png" /></figure><p>The key message is:</p><blockquote><strong><em>Streamlit can serve as the application layer while specialized services provide authentication, persistence, and AI inference.</em></strong></blockquote><h3>2. Technologies</h3><p>The tutorial would use:</p><ul><li><strong>Streamlit</strong> — application UI</li><li><strong>Streamlit Community Cloud</strong> — deployment</li><li><strong>Supabase</strong> — authentication + PostgreSQL + Storage</li><li><strong>Python</strong> — application logic</li><li><strong>scikit-learn</strong> — lightweight ML model</li><li><strong>pickle/joblib</strong> — model serialization</li><li><strong>Nativefier</strong> — desktop wrapper</li><li><strong>Vertex AI / Roboflow</strong> — optional computer-vision inference APIs</li></ul><p>One thing I’d emphasize: <strong>Nativefier doesn’t turn Streamlit into a truly native application</strong>. It packages a web application inside a desktop shell, essentially using Electron. That’s an important distinction for a technically rigorous article.</p><h3>3. Project structure</h3><p>Start with something like:</p><pre>streamlit-ai-app/<br>│<br>├── app.py<br>├── requirements.txt<br>│<br>├── models/<br>│   └── classifier.pkl<br>│<br>├── pages/<br>│   ├── home.py<br>│   ├── prediction.py<br>│   └── profile.py<br>│<br>└── utils/<br>    ├── auth.py<br>    ├── database.py<br>    └── inference.py</pre><p>This immediately makes the tutorial more sophisticated than the typical single-file Streamlit example.</p><h3>4. Setting up Supabase</h3><p>Create a Supabase project and configure:</p><pre>Authentication<br>     │<br>     ├── Email/password<br>     │<br>     └── OAuth (optional)<br>     <br>Database<br>     │<br>     ├── users<br>     ├── predictions<br>     └── measurements</pre><pre>Storage<br>     │<br>     └── images/</pre><p>For example:</p><pre>CREATE TABLE predictions (<br>    id BIGSERIAL PRIMARY KEY,<br>    user_id UUID REFERENCES auth.users(id),<br>    prediction TEXT,<br>    probability FLOAT,<br>    created_at TIMESTAMPTZ DEFAULT NOW()<br>);</pre><p>Then enable <strong>Row Level Security (RLS)</strong>.</p><p>For example:</p><pre>CREATE POLICY &quot;Users can see their own predictions&quot;<br>ON predictions<br>FOR SELECT<br>USING (auth.uid() = user_id);</pre><p>This is where you can explain an important concept:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BYRetLhpls7WPjTNsEy68w.png" /></figure><p>Supabase Authentication provides the identity, while PostgreSQL/RLS determines what that identity is allowed to access.</p><h3>5. Connecting Streamlit to Supabase</h3><p>Install:</p><pre>$ pip install streamlit supabase</pre><p>Then store credentials using Streamlit secrets:</p><pre>SUPABASE_URL = &quot;https://xxxxx.supabase.co&quot;<br>SUPABASE_KEY = &quot;your-key&quot;</pre><p>And connect:</p><pre>import streamlit as st<br>from supabase import create_client</pre><pre>supabase = create_client(<br>    st.secrets[&quot;SUPABASE_URL&quot;],<br>    st.secrets[&quot;SUPABASE_KEY&quot;]<br>)</pre><p>I’d specifically explain that <strong>secrets should never be hard-coded into GitHub</strong>.</p><h3>6. Authentication</h3><p>Create a login interface:</p><pre>email = st.text_input(&quot;Email&quot;)<br>password = st.text_input(<br>    &quot;Password&quot;,<br>    type=&quot;password&quot;<br>)</pre><pre>if st.button(&quot;Login&quot;):</pre><pre>    response = supabase.auth.sign_in_with_password({<br>        &quot;email&quot;: email,<br>        &quot;password&quot;: password<br>    })</pre><pre>    if response.user:<br>        st.session_state[&quot;user&quot;] = response.user<br>        st.session_state[&quot;session&quot;] = response.session</pre><pre>        st.success(&quot;Login successful&quot;)</pre><p>Then:</p><pre>if &quot;user&quot; not in st.session_state:<br>    st.stop()</pre><p>This creates a simple protected application.</p><p>You can then display:</p><pre>user = st.session_state[&quot;user&quot;]</pre><pre>st.write(<br>    f&quot;Welcome {user.email}&quot;<br>)</pre><h3>7. Deploying to Streamlit Community Cloud</h3><p>The workflow is very clean:</p><pre>Local development<br>       ↓<br>GitHub repository<br>       ↓<br>Streamlit Community Cloud<br>       ↓<br>Public/private web application</pre><p>The requirements.txt might contain:</p><pre>streamlit<br>supabase<br>scikit-learn<br>numpy<br>pandas</pre><p>Then connect the GitHub repository to Streamlit Community Cloud.</p><p>The article should explain that <strong>Streamlit Cloud is hosting the Python application</strong>; Supabase remains the backend service.</p><h3>8. Turning it into a desktop application</h3><p>This is a fun part of the tutorial.</p><p>Once the Streamlit application is deployed, you can package its URL using Nativefier.</p><p>Conceptually:</p><pre>Streamlit Cloud<br>       │<br>       │ HTTPS<br>       ▼<br>   Web application<br>       │<br>       ▼<br>   Nativefier<br>       │<br>       ▼<br>Desktop executable</pre><p>Link to Nativefier: <a href="https://nativefier.org/#Installation">https://nativefier.org/#Installation</a></p><p>To install:</p><pre>$ npm install -g nativefier </pre><p>Basic examples:</p><pre>$ nativefier &quot;https://web.whatsapp.com&quot; --platform &#39;windows&#39;<br>$ nativefier --name &quot;MyApp&quot; --icon ./icon.png --width 1280 --height 800 &quot;https://myapp.com&quot;<br>$ nativefier --name &#39;&lt;your .exe name&gt;&#39; &#39;&lt;your Streamlit sharing website URL&gt;&#39; --platform &lt;&#39;windows&#39; or &#39;mac&#39; or &#39;linux&#39;&gt;<br>$ nativefier --name &quot;My Streamlit App&quot; &quot;http://localhost:8501/&quot; --platform &quot;windows&quot; --ignore-certificate --insecure<br>$ nativefier --name Audiofy https://share.streamlit.io/sree369nidhi/audiobook/main/pdf_to_audiobook.py --platform windows</pre><p>For example:</p><pre>nativefier &quot;https://your-app.streamlit.app&quot;</pre><p>This creates a desktop application that opens the Streamlit application in an Electron-based wrapper.</p><p>I’d explicitly say:</p><blockquote><em>This does </em><strong><em>not</em></strong><em> move Streamlit or Python inference onto the user’s computer. The desktop application is essentially a packaged browser pointing to the deployed Streamlit application.</em></blockquote><p>That’s an important architectural distinction.</p><h3>9. Adding a small ML model</h3><p>Now the tutorial becomes more interesting.</p><p>Train a small scikit-learn model:</p><pre>from sklearn.ensemble import RandomForestClassifier<br>import pickle</pre><pre>model = RandomForestClassifier(<br>    n_estimators=100,<br>    random_state=42<br>)</pre><pre>model.fit(X_train, y_train)</pre><pre>with open(&quot;classifier.pkl&quot;, &quot;wb&quot;) as f:<br>    pickle.dump(model, f)</pre><p>Store:</p><pre>models/<br>    classifier.pkl</pre><p>Then load it from Streamlit:</p><pre>import pickle</pre><pre>with open(&quot;models/classifier.pkl&quot;, &quot;rb&quot;) as f:<br>    model = pickle.load(f)</pre><p>And perform inference:</p><pre>prediction = model.predict(<br>    [[feature_1, feature_2, feature_3]]<br>)</pre><pre>probability = model.predict_proba(<br>    [[feature_1, feature_2, feature_3]]<br>)</pre><h3>10. Explain why this is possible</h3><p>This is where your article can make a valuable conceptual point.</p><p>A small traditional ML model might be:</p><pre>Random Forest<br>10–100 trees<br>few MB<br>CPU inference<br>milliseconds</pre><p>Therefore:</p><pre>Streamlit<br>   │<br>   ▼<br>Python<br>   │<br>   ▼<br>scikit-learn<br>   │<br>   ▼<br>classifier.pkl<br>   │<br>   ▼<br>prediction</pre><p>You don’t necessarily need a GPU.</p><p>This is very different from something like:</p><pre>ResNet<br>YOLO<br>Vision Transformer<br>Large CNN</pre><p>where inference may require considerably more computational resources.</p><h3>11. Important security warning about pickle</h3><p>I would definitely include this in a Medium tutorial.</p><p>pickle should <strong>not be treated as a safe interchange format</strong>.</p><p>Never load an untrusted .pkl file:</p><pre>pickle.load(untrusted_file)</pre><p>because Python pickle deserialization can execute arbitrary code.</p><p>So explain:</p><blockquote><em>Only load model files generated and controlled by your own trusted training pipeline.</em></blockquote><p>You could also mention <strong>joblib</strong> and, depending on the model/runtime, safer interchange formats such as <strong>ONNX</strong>.</p><h3>12. Now introduce computer vision</h3><p>This is where the architecture evolves.</p><p>Suppose the application needs to analyze an image:</p><pre>User<br> │<br> │ uploads image<br> ▼<br>Streamlit<br> │<br> ▼<br>Computer Vision API<br> │<br> ├── Roboflow<br> │<br> └── Vertex AI<br> │<br> ▼<br>Prediction<br> │<br> ▼<br>Streamlit</pre><p>The important conceptual difference is:</p><h3>Small ML</h3><pre>Streamlit<br>   ↓<br>Python<br>   ↓<br>.pkl<br>   ↓<br>Prediction</pre><h3>Heavy computer vision</h3><pre>Streamlit<br>   ↓<br>API request<br>   ↓<br>Cloud GPU / AI infrastructure<br>   ↓<br>Computer Vision model<br>   ↓<br>JSON prediction<br>   ↓<br>Streamlit</pre><p>This is a much more scalable architecture.</p><h3>13. Roboflow example</h3><p>For a custom object detector, the application could send an image to a Roboflow inference endpoint.</p><p>Conceptually:</p><pre>import requests</pre><pre>response = requests.post(<br>    ROBOFLOW_ENDPOINT,<br>    files={<br>        &quot;file&quot;: uploaded_image<br>    }<br>)</pre><pre>result = response.json()</pre><p>Then Streamlit displays:</p><pre>Image<br> ├── Person: 0.94<br> ├── Object A: 0.87<br> └── Object B: 0.76</pre><p>This allows you to keep the Streamlit application lightweight.</p><h3>14. Vertex AI</h3><p>The same architecture can be used with Google Cloud Vertex AI:</p><pre>Streamlit<br>    │<br>    │ REST/API<br>    ▼<br>Vertex AI Endpoint<br>    │<br>    ▼<br>Computer Vision Model<br>    │<br>    ▼<br>Prediction<br>    │<br>    ▼<br>Streamlit</pre><p>This becomes particularly attractive when your model is too computationally expensive for a normal Streamlit CPU environment.</p><h3>15. The final architecture</h3><p>I’d finish the article by bringing everything together:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6t-A5jtHVR9CH7zDlvITig.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zWozv9TuLBDnPkHHSAl-2A.png" /></figure><p>And then make the key conclusion:</p><blockquote><strong><em>The strength of this architecture isn’t that Streamlit does everything. Its strength is that Streamlit acts as a simple Python application layer while specialized services handle authentication, persistence, storage, and computationally expensive AI workloads.</em></strong></blockquote><p>That’s a much stronger technical story for Medium than simply writing “How to use Supabase with Streamlit.”</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6042a6fc1d9c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Idea to Software: A Practical Software Design Workflow Using IEEE, ISO, UML, and C4]]></title>
            <link>https://medium.com/@moises.meza/from-idea-to-software-a-practical-software-design-workflow-using-ieee-iso-uml-and-c4-d69a971e115d?source=rss-4a1f1f4dd7a8------2</link>
            <guid isPermaLink="false">https://medium.com/p/d69a971e115d</guid>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Moises Meza]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 04:05:46 GMT</pubDate>
            <atom:updated>2026-08-19T15:35:14.447Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>I’d start by asking:</p><blockquote><em>“Many developers start coding immediately after having an idea. Software engineers don’t. They design first.”</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/563/1*Xxf-ORAJw0NNZC2ikpdlQA.png" /><figcaption>Standards for design a system</figcaption></figure><h3>Architecture by SCOPE (The “Layers” of a System)</h3><p>When a CTO or Lead Architect talks about “<strong>system architecture</strong>,” they usually refer to one of these four overlapping domains:</p><ul><li><strong>Business Architecture</strong>: The organizational structure, business strategies, governance, and KPIs that the system must support.</li><li><strong>Data Architecture</strong>: How data is collected, stored, processed, and governed (data lakes, warehouses, data mesh, master data management).</li><li><strong>Application Architecture</strong>: The blueprint of individual software applications, their modules, and how they interact internally (this is where most “software architectures” live).</li><li><strong>Infrastructure/Technical Architecture:</strong> The hardware, servers, virtualization, containers, and networking that host the applications (on-prem, cloud, edge).</li></ul><h3>Architecture by STRUCTURAL STYLE (The “Topology”)</h3><p>These are the broad, high-level shapes a system takes:</p><ul><li>Monolithic Architecture: The entire application is built as a single, indivisible unit. All code is deployed together. (Simple, but rigid).</li><li>Service-Oriented Architecture (SOA): A collection of loosely coupled services that communicate via an Enterprise Service Bus (ESB). Focuses on reusing business functionalities across the enterprise.</li><li>Microservices Architecture: A collection of fine-grained, independently deployable services. Each service owns its own database and communicates via lightweight APIs (REST, gRPC).</li><li>Serverless Architecture (FaaS): The cloud provider manages the servers. You deploy individual functions that execute in stateless compute containers, triggered by events (e.g., AWS Lambda).</li><li>Event-Driven Architecture (EDA): Systems communicate by producing and consuming events via a message broker (e.g., Kafka, RabbitMQ). Components are decoupled and react asynchronously.</li><li>Space-Based Architecture (SBA): Also called “Cloud Architecture.” Designed to handle high load by removing the central database and using in-memory data grids. Processing is distributed across multiple nodes.</li><li>Peer-to-Peer (P2P) Architecture: No central server; every node acts as both a client and a server (e.g., BitTorrent, blockchain networks).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yB3Uvn-FuDpj3ePH5kUDJQ.png" /></figure><h3><strong>The Complete Workflow</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/1*_Tl1BHu-OWG9JGXnZIp_7w.png" /></figure><h3>Phase 1 — Idea/Product Vision</h3><h4>Goal</h4><p>Before coding, it is important to understand what is the problem this software is going to solve, even before thinking about the technology.</p><p><strong>Some useful questions</strong></p><ul><li>What is the main problem?</li><li>What is the main system objective?</li><li>How is it going to be used? USER, CLIENTS, ADMIN, ETC</li><li>What are the benefits?</li><li>What will the product be?</li></ul><pre>Template:<br><br>- Problem<br>- Objectives (Goals)<br>- Solution to present (Project scope) <br>- Stakeholders (Target users)<br>- Success Metrics</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RU4C27AD3twnC7LmKi7EkA.png" /></figure><h3><strong>Phase 2 — Requirements Engineering</strong></h3><p>Many developers confuse requirements with features.</p><p>A requirement describes <strong>what</strong> the system must accomplish — not <strong>how</strong> it will be implemented.</p><p>For example:</p><ul><li>❌ Bad requirement:<em> Use PostgreSQL.</em></li><li>✔ Good requirement: <em>The system shall store user progress permanently.</em></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z0MN_CwN5wKhP4mD1r9QNw.png" /></figure><p>Requirements are usually classified into:</p><ul><li>Functional Requirements</li><li>Non-functional Requirements</li><li>Business Rules</li><li>Constraints</li></ul><p>A good requirement should be <strong>atomic</strong>, <strong>testable</strong>, <strong>unambiguous</strong>, <strong>feasible</strong>, and <strong>traceable</strong>.</p><p>Introduce the SMART criteria or IEEE characteristics briefly.</p><h3>Phase 3 — Business Modeling</h3><p>Software supports a business process.</p><p>If you don’t understand the workflow, you’ll automate the wrong process.</p><p>Example:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iw4UL-PyFTqCwR3sRhWW1A.png" /></figure><p>Tools:</p><ul><li>BPMN</li><li>UML Activity Diagrams</li><li>C4</li></ul><h3>Phase 4 — Domain Modeling</h3><p>One of the biggest mistakes beginners make is designing database tables before understanding the domain.</p><p>The domain model describes <strong><em>concepts </em></strong>— not tables.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tpCAQRtI_SEVGzRRbRmzyA.png" /></figure><p>Notice these are business concepts.</p><p>Later they may become classes, tables, APIs, or services.</p><p>Domain modeling reduces duplicated logic and creates a shared vocabulary between developers and stakeholders.</p><p>Mention Evans’ Domain-Driven Design here.</p><h3>Phase 5 — Software Architecture</h3><p>Architecture is not about choosing frameworks.</p><p>Architecture is about making decisions that are difficult to change later.</p><p>For example:</p><ul><li>Monolith or Microservices?</li><li>Layered Architecture?</li><li>Event-driven?</li><li>Hexagonal?</li><li>Clean Architecture?</li></ul><p>The C4 Model has become one of the most practical ways to document architecture.</p><p>Explain briefly:</p><ul><li>Context</li><li>Container</li><li>Component</li><li>Code</li></ul><p>Include a miniature example.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9rnfbpTlZuV8bxf-cKQhog.png" /></figure><h3>Phase 6 — Database Design</h3><p>A database should represent the domain — not the user interface.</p><p>Instead of immediately creating tables, define:</p><ul><li>Entities</li><li>Relationships</li><li>Constraints</li><li>Cardinality</li><li>Keys</li><li>Normalization</li></ul><p>Then create an ER Diagram.</p><p>Explain why normalization matters but also mention that denormalization is sometimes appropriate for performance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0pU3W4kh10SWM8oDkSP84A.png" /></figure><h3>Phase 7 — Behavioral Modeling</h3><p>Structure alone is insufficient.</p><p>Behavior also needs to be modeled.</p><p>Useful UML diagrams include:</p><ul><li>Sequence Diagram</li><li>Activity Diagram</li><li>State Diagram</li></ul><p>Each answers a different question:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/530/1*3TfLqzXIoc_3e3fKlen-FQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sN6lygO-mjCFvFkmMJ2x-w.png" /></figure><h3>Phase 8 — UI/UX Design</h3><p>Design interfaces before coding them.</p><p>Start with:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VI29T_x4iySmZSIGfGChbQ.png" /></figure><p>Modern tools include:</p><ul><li>Figma</li><li>Penpot</li><li>Balsamiq</li></ul><p>Early prototypes reduce misunderstandings and save development time.</p><h3>Phase 9 — Implementation</h3><p>Only now should development begin.</p><p>At this point, most major decisions have already been made.</p><p>Developers can focus on writing maintainable code instead of debating architecture during implementation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8IrwAPg6zuikZY2EBmlRBQ.png" /></figure><h3>Phase 10 — Testing &amp; Deployment</h3><p>Testing verifies that software behaves as intended.</p><p>Deployment makes it available to users.</p><p>Both should be automated whenever possible using CI/CD pipelines.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d69a971e115d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Zero to PostgreSQL: A Quick Guide to Mastering the Console]]></title>
            <link>https://medium.com/@moises.meza/from-zero-to-postgresql-a-quick-guide-to-mastering-the-console-1994f2c32d00?source=rss-4a1f1f4dd7a8------2</link>
            <guid isPermaLink="false">https://medium.com/p/1994f2c32d00</guid>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[sql]]></category>
            <dc:creator><![CDATA[Moises Meza]]></dc:creator>
            <pubDate>Mon, 03 Aug 2026 01:47:32 GMT</pubDate>
            <atom:updated>2026-08-03T15:00:32.288Z</atom:updated>
            <content:encoded><![CDATA[<p>Before you start, you have to install PostgreSQL and PGAdmin; both are available to download using this <a href="https://www.enterprisedb.com/downloads/postgres-postgresql-downloads">link</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZxuY-_P-juaAguJH8aLAZw.png" /></figure><p><strong>How to take your first steps in the world’s most powerful relational database engine without leaving the terminal.</strong></p><p>If you are entering the world of data management, you have probably heard of PostgreSQL (or simply Postgres). With over 35 years of development, it has become the gold standard of open-source databases. From storing simple financial records to serving as the main backend for complex Artificial Intelligence and Natural Language Processing (NLP) architectures, Postgres can handle it all.</p><p>Unlike heavy graphical environments, the true magic and speed of Postgres are experienced from its command line: <strong>psql</strong>.</p><p>Here is a 5-minute tutorial to help you lose your fear of the console and master the essentials.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JAyl3k_NuosrFGfNwV8RkQ.png" /></figure><h3>Step 1: Entering the Server</h3><p>Assuming you already have PostgreSQL installed on your computer, open your terminal (or Command Prompt in Windows) and type the following command to connect as the default administrator user:</p><p>Bash</p><pre>$ psql -U postgres</pre><p><em>Note: It will ask for the password you set during installation. When typing it, you won’t see asterisks for security reasons. Just type it in and press Enter.</em></p><p>If you see that your console prompt now starts with: postgres=#, congratulations! You are in.</p><h3>Step 2: Quick Navigation (Meta-commands)</h3><p>In psql, you don&#39;t need to write long SQL statements to see what&#39;s on your server. You can use quick shortcuts that always start with a backslash (\):</p><ul><li><strong>\l</strong> : Lists all databases created on your server.</li><li><strong>\c database_name</strong> : Connects you (enters) to a specific database.</li><li><strong>\dt</strong> : Shows all tables within the current database.</li><li><strong>\d table_name</strong> : Describes the structure of a table (its columns and data types).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/712/1*uYguyRPtCBznE9BgF2z71Q.png" /><figcaption>Entering to postgres in CMD</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mXdTWrsAP9aOC1ZesO6TCA.png" /><figcaption>Listing all tha databases in the User “postgres”</figcaption></figure><p><strong>\c</strong> is the option to enter into a database</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/923/1*mCwKnDqgxwbLfzdL5VwDoA.png" /><figcaption>by default the datase named posgres is accessed</figcaption></figure><p>We can access another database using <strong>\c</strong> and the name of the database like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*mVWlkHtv8ONSE1xWwVVJ5g.png" /><figcaption>Check that when a DB is accessed, the name in CMD change</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/426/1*7Jj112o-ctq200ylxnjTIw.png" /><figcaption>Check the tables in a database.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*zuPQN_vAOIlGj0MagdaIVQ.png" /><figcaption>Inspect the structure of th table named “ethics_Studies”</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/695/1*OPh95lGeSgc1vfWJAnsu6A.png" /><figcaption>Having selecting a table, it is possible to check the content of the table.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*h52VFw3gADMGIE7gu3GJSA.png" /><figcaption>Having a sql file, it is possible to run using the command<strong> ‘\i’</strong></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/630/1*DbxO16vkZIonYwQanceipA.png" /><figcaption>The content of file named<strong> “tabla_nueva.sql”</strong></figcaption></figure><h3>Step 3: Creating your First Database and Table</h3><p>Let’s create a test environment from scratch. First, we create the database and connect to it:</p><p>SQL</p><pre>CREATE DATABASE laboratory;<br>\c laboratory</pre><p>Now, let’s create a simple table to register research projects:</p><p>SQL</p><pre>CREATE TABLE studies (<br>    project_id VARCHAR(50) PRIMARY KEY,<br>    researcher_name VARCHAR(100),<br>    approved BOOLEAN,<br>    similarity_percentage INTEGER<br>);</pre><p>When a Database and then a table are created, automatically a <strong><em>SCHEMA </em></strong>is created with the name <strong><em>PUBLIC.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/308/1*v6GTJGB0a5Lr6K5uCPLhzA.png" /><figcaption>\dn list all the schemas</figcaption></figure><h3>Step 4: Inserting and Querying Data (The famous CRUD)</h3><p>To save information in our new structure, we use the INSERT command:</p><p>SQL</p><pre>INSERT INTO studies (project_id, researcher_name, approved, similarity_percentage) <br>VALUES <br>(&#39;EST-001&#39;, &#39;Dr. Silva&#39;, true, 12),<br>(&#39;EST-002&#39;, &#39;Dr. Mendoza&#39;, false, 45);</pre><p>Finally, to see our data, we use a SELECT query:</p><p>SQL</p><pre>SELECT * FROM studies;</pre><p><strong>🔥 The golden trick (Expanded View):</strong> If your table has too many columns and the text gets deformed on your screen when running the SELECT command, simply type \x and press Enter before querying. This will activate the expanded display, showing each record as a clean, easy-to-read vertical list.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VFmCNVunz3KVgeWLdiSPsg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3HpoXaU2DhvXmLzGCEcQvw.png" /></figure><h3>Next Steps</h3><p>Exiting the console is as easy as typing <strong>\q</strong>.</p><p>Learning to manage PostgreSQL from the command line not only makes you faster but gives you a deep understanding of how applications communicate with databases. The next step is to experiment by importing massive CSV files or connecting this database to your favorite analysis tool.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1994f2c32d00" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding KiCad Beyond the Software: A Beginner’s Guide to Symbols, Reference Designators, and…]]></title>
            <link>https://medium.com/@moises.meza/understanding-kicad-beyond-the-software-a-beginners-guide-to-symbols-reference-designators-and-836629a06ce5?source=rss-4a1f1f4dd7a8------2</link>
            <guid isPermaLink="false">https://medium.com/p/836629a06ce5</guid>
            <dc:creator><![CDATA[Moises Meza]]></dc:creator>
            <pubDate>Thu, 09 Jul 2026 23:20:11 GMT</pubDate>
            <atom:updated>2026-08-03T00:56:01.902Z</atom:updated>
            <content:encoded><![CDATA[<h3>Understanding KiCad Beyond the Software: A Beginner’s Guide to Symbols, Reference Designators, and Components</h3><p><em>Learn the language of electronic schematics before learning the buttons.</em></p><h3>Introduction</h3><p>When most people start learning <strong>KiCad</strong>, they immediately search for tutorials on topics such as:</p><ul><li>How to draw a schematic</li><li>How to route a PCB</li><li>How to generate Gerber files</li></ul><p>While these are important skills, they often miss a more fundamental question:</p><blockquote><strong><em>What am I actually placing on the schematic?</em></strong></blockquote><p>Understanding the meaning of electronic symbols, reference designators, component types, and footprints will make you a much better PCB designer than simply memorizing KiCad’s interface.</p><p>This article introduces the concepts every beginner should master before designing their first PCB.</p><h3>The Four Identities of Every Electronic Component</h3><p>One of the most important concepts in PCB design is that every component exists in four different forms.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AxyjGyZ-Y3C29yuerr5bvw.png" /></figure><p>Understanding this relationship eliminates much of the confusion beginners have when using KiCad.</p><h3>What is a Reference Designator?</h3><p>Every component placed in a schematic receives a <strong>reference designator</strong>.</p><p>Think of it as the component’s unique identifier.</p><p>Examples:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/493/1*dEnUs2l1cfGu6V9JzD3jKw.png" /></figure><p>Notice that two resistors may both have the value <strong>10 kΩ</strong>, but they still need different names.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/461/1*JXtzmzDhtTJy3ipgUDuQGQ.png" /></figure><p>Without reference designators, troubleshooting or assembling a PCB would be nearly impossible.</p><h3>Reference vs Value vs Footprint</h3><p>These three fields are frequently confused.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/591/1*3tfSPcqQCvcAiQDZFIHcnQ.png" /></figure><p>For example,</p><pre>Reference : R5<br>Value      : 10 kΩ<br>Footprint  : R_0603</pre><p>means</p><ul><li><strong>R5</strong> is the fifth resistor in the design.</li><li>It has a resistance of <strong>10 kΩ</strong>.</li><li>It will be soldered using an <strong>0603 SMD package</strong>.</li></ul><h3>The Most Common Reference Designators</h3><p>The following table summarizes the designators you’ll encounter in most PCB projects.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/495/1*S9CpndERPO0pV7D6sN--uw.png" /></figure><h3>Why Are Integrated Circuits Named “U”?</h3><p>A common question among beginners is:</p><blockquote><em>Why isn’t an integrated circuit called “IC1”?</em></blockquote><p>Historically,</p><ul><li>R = Resistor</li><li>C = Capacitor</li><li>L = Inductor</li><li>D = Diode</li><li>Q = Transistor</li></ul><p>When integrated circuits became popular, many letters had already been assigned to other components.</p><p>The letter <strong>U</strong> became the accepted designator for integrated circuits and remains the convention today.</p><p>Examples include:</p><ul><li>U1 → ESP32</li><li>U2 → STM32</li><li>U3 → Operational Amplifier</li><li>U4 → Voltage Regulator</li></ul><h3>Understanding KiCad Symbol Fields</h3><p>Every symbol in KiCad contains several fields.</p><p>Some are built into KiCad, while others can be customized.</p><h3>Built-in Fields</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*V_x1iH7mnypjIGE21SC8zA.png" /></figure><h3>Custom Fields</h3><p>One of KiCad’s greatest strengths is that you can create your own fields.</p><p>Examples include:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/518/1*o4voDp9rdY2UUNWMrmxljw.png" /></figure><p>KiCad places no practical limit on the number of custom fields.</p><p>These fields become especially useful when generating Bills of Materials (BOMs).</p><h3>Understanding Component Packages</h3><p>Every schematic symbol eventually needs a physical footprint.</p><p>Two major package families exist.</p><h3>Through-Hole (THT)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YyX9H47Fr5EnHIJEORAUDQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ajGpcUItJXExKpQ-Z6p-BQ.png" /><figcaption>Capacitor_THT:CP_Radial_D5.0mm_P2.50mm</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ns8AA07k1v7fxA6F.jpg" /><figcaption>TO-92 vs TO-02s</figcaption></figure><p>Examples</p><ul><li>Axial resistor</li><li>Radial capacitor</li><li>DIP integrated circuits</li><li>TO-220</li><li>TO-92</li></ul><p>Advantages</p><ul><li>Easy to solder</li><li>Breadboard compatible</li><li>Excellent for education</li></ul><p>Disadvantages</p><ul><li>Larger</li><li>Requires drilled holes</li></ul><h3>Surface Mount (SMD)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FSveAR0pVhSctis36cZO5Q.png" /></figure><p>Examples</p><p>Passive Components | Integrated Circuits</p><ul><li>0402 — SOIC</li><li>0603 — TSSOP</li><li>0805 — QFP</li><li>1206 — QFN</li><li>1210 — BGA</li></ul><p>Advantages</p><ul><li>Smaller</li><li>Higher component density</li><li>Preferred for commercial products</li></ul><p>Disadvantages</p><ul><li>More difficult to solder manually</li><li>Requires greater manufacturing precision</li></ul><h3>Understanding Connectors</h3><p>One misconception beginners often have is believing that every connector requires a unique schematic symbol.</p><p>In reality, many physical connectors share exactly the same schematic symbol.</p><p>For example,</p><ul><li>JST connector</li><li>Molex connector</li><li>Pin Header</li><li>Screw Terminal</li></ul><p>may all use the same generic symbol:</p><pre>Connector_Generic:Conn_01x04</pre><p>The <strong>footprint</strong>, not the symbol, determines the actual connector placed on the PCB.</p><h3>Common Connector Families</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NjY7R5M0st9pqDkUXt8Jhw.png" /></figure><p>In KiCad, nearly all connectors use the reference designator:</p><pre>J1<br>J2<br>J3</pre><h3>How Engineers Search for Components</h3><p>Beginners often search for components like this:</p><blockquote><em>“resistor”</em></blockquote><p>Experienced engineers search using specifications.</p><p>For example:</p><p>Component — Search Criteria</p><ul><li>Resistor 10 kΩ, ±1%, 0603, 0.1 W</li><li>Capacitor 100 nF, X7R, 50 V, 0603</li><li>LED Green, 1206, 20 mA</li><li>MCU Cortex-M4, USB, 512 KB Flash</li></ul><p>Learning to read datasheets is just as important as learning KiCad.</p><h3>A Better Way to Learn KiCad</h3><p>Instead of learning menus and buttons, learn the engineering concepts behind them.</p><p>A recommended progression is:</p><ol><li>Read electronic schematics.</li><li>Learn reference designators.</li><li>Understand schematic symbols.</li><li>Learn package families (THT vs. SMD).</li><li>Understand footprints.</li><li>Read datasheets.</li><li>Build simple circuits.</li><li>Design increasingly complex PCBs.</li></ol><p>When you understand the concepts, KiCad becomes much easier to use.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/675/1*gz1LElM2Ies3B1nnywX1wA.jpeg" /><figcaption>“pin socket” or “dip socket”</figcaption></figure><p>An IC socket is soldered onto the PCB, allowing you to <strong>plug in</strong> and <strong>remove</strong> a Dual In-line Package (DIP) integrated circuit without soldering the IC itself.</p><h3>In KiCad</h3><p>In KiCad you’ll typically find these under libraries such as:</p><ul><li><strong>Socket</strong></li><li><strong>Package_DIP</strong></li><li><strong>Connector_PinSocket</strong> (for some socket-like components)</li></ul><p>Typical footprints include:</p><pre>Package_DIP:DIP-8_W7.62mm_Socket<br>Package_DIP:DIP-14_W7.62mm_Socket<br>Package_DIP:DIP-16_W7.62mm_Socket<br>Package_DIP:DIP-20_W7.62mm_Socket<br>Package_DIP:DIP-28_W7.62mm_Socket<br>Package_DIP:DIP-40_W15.24mm_Socket</pre><h3>Final Thoughts</h3><p>KiCad is not just PCB software — it is a tool for expressing electronic designs.</p><p>The real challenge is not learning where to click, but understanding:</p><ul><li>what each symbol represents,</li><li>why a particular footprint is selected,</li><li>how components are identified,</li><li>and how they come together to form a working electronic system.</li></ul><p>Once you master these fundamentals, designing PCBs becomes a process of applying engineering knowledge rather than following software tutorials.</p><h3>Some useful components in KiCad</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qKEAf6LX4OoXOEgSx8yLvA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=836629a06ce5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Streamlit from Scratch: Build Your First Interactive Python Web App in Minutes]]></title>
            <link>https://medium.com/@moises.meza/streamlit-from-scratch-build-your-first-interactive-python-web-app-in-minutes-67817fae4f32?source=rss-4a1f1f4dd7a8------2</link>
            <guid isPermaLink="false">https://medium.com/p/67817fae4f32</guid>
            <category><![CDATA[streamlit]]></category>
            <dc:creator><![CDATA[Moises Meza]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 13:12:55 GMT</pubDate>
            <atom:updated>2026-07-03T13:20:01.958Z</atom:updated>
            <content:encoded><![CDATA[<p>Python developers often build scripts, models, and data pipelines, but turning them into interactive applications usually requires learning web frameworks like Flask or Django.</p><p>That is where Streamlit changes the game.</p><p>Streamlit allows you to transform Python scripts into web applications with minimal code, making it especially useful for:</p><ul><li>Data science</li><li>Machine learning</li><li>Research prototypes</li><li>Signal processing dashboards</li><li>Biomedical data visualization</li></ul><p>In this tutorial, we will build a complete Streamlit application from scratch.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TMWFN5di_66ldRi-H4qelQ.png" /></figure><h3>What is Streamlit?</h3><p>Streamlit is an open-source Python framework for building interactive web applications focused on data.</p><p>Unlike traditional web development, Streamlit removes the need for:</p><ul><li>HTML</li><li>CSS</li><li>JavaScript</li><li>Backend routing</li></ul><p>Everything is done directly in Python.</p><p>This makes development significantly faster for technical users.</p><h3>Installation</h3><p>First, create a virtual environment:</p><pre>python -m venv st-venv</pre><p>o tambien desde conda</p><pre>conda create -n st-env python=3.12 -y</pre><p>Activate it:</p><h3>Windows</h3><pre>venv\Scripts\activate</pre><h3>Linux / Mac</h3><pre>source st-venv/bin/activate</pre><p>Now install Streamlit:</p><pre>pip install streamlit</pre><p>Verify installation:</p><pre>streamlit --version</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HhH5pTxafTCmdxg2QoTQvQ.png" /></figure><h3>Your First Streamlit App</h3><p>Create a file called:</p><pre>app.py</pre><p>Add:</p><pre>import streamlit as st</pre><pre>st.title(&quot;My First Streamlit App&quot;)<br>st.write(&quot;Hello world!&quot;)</pre><p>Run:</p><pre>streamlit run app.py</pre><p>Your browser will automatically open:</p><pre>http://localhost:8501</pre><p>That is your first web app.</p><h3>Understanding the Core Structure</h3><p>Streamlit executes your script from top to bottom every time a user interacts.</p><p>Basic structure:</p><pre>import streamlit as st</pre><pre>st.title(&quot;Title&quot;)<br>st.header(&quot;Header&quot;)<br>st.subheader(&quot;Subheader&quot;)<br>st.text(&quot;Plain text&quot;)<br>st.write(&quot;Flexible output&quot;)</pre><p>Main components:</p><p>FunctionPurposest.title()Main titlest.header()Section headerst.subheader()Smaller headerst.text()Raw textst.write()Generic output</p><p>st.write() is the most flexible.</p><p>It can render:</p><ul><li>text</li><li>variables</li><li>lists</li><li>dictionaries</li><li>dataframes</li></ul><p>Example:</p><pre>number = 42<br>st.write(&quot;The number is:&quot;, number)</pre><h3>Interactive Widgets</h3><p>This is where Streamlit becomes powerful.</p><h3>Text input</h3><pre>name = st.text_input(&quot;Enter your name&quot;)</pre><pre>if name:<br>    st.write(&quot;Hello,&quot;, name)</pre><h3>Slider</h3><pre>age = st.slider(&quot;Select your age&quot;, 0, 100, 25)</pre><pre>st.write(&quot;Your age:&quot;, age)</pre><p>Parameters:</p><pre>st.slider(label, min, max, default)</pre><h3>Button</h3><pre>if st.button(&quot;Click me&quot;):<br>    st.write(&quot;Button pressed!&quot;)</pre><p>Buttons return Boolean values.</p><h3>Selectbox</h3><pre>option = st.selectbox(<br>    &quot;Choose one option&quot;,<br>    [&quot;Python&quot;, &quot;C++&quot;, &quot;Java&quot;]<br>)</pre><pre>st.write(&quot;Selected:&quot;, option)</pre><h3>Displaying Data</h3><p>Streamlit integrates very well with Pandas.</p><p>Install:</p><pre>pip install pandas</pre><p>Example:</p><pre>import pandas as pd<br>import streamlit as st</pre><pre>data = {<br>    &quot;Name&quot;: [&quot;Alice&quot;, &quot;Bob&quot;, &quot;Charlie&quot;],<br>    &quot;Age&quot;: [25, 30, 35]<br>}</pre><pre>df = pd.DataFrame(data)</pre><pre>st.dataframe(df)</pre><p>Difference:</p><ul><li>st.table(df) → static</li><li>st.dataframe(df) → interactive</li></ul><h3>Plotting Graphs</h3><p>Install:</p><pre>pip install matplotlib</pre><p>Example:</p><pre>import matplotlib.pyplot as plt<br>import streamlit as st</pre><pre>x = [1, 2, 3, 4]<br>y = [10, 20, 15, 30]</pre><pre>fig, ax = plt.subplots()<br>ax.plot(x, y)</pre><pre>st.pyplot(fig)</pre><p>This is useful for:</p><ul><li>ECG visualization</li><li>EMG analysis</li><li>Sensor signals</li><li>Training curves</li></ul><h3>Uploading Files</h3><p>One of the most useful features.</p><pre>uploaded_file = st.file_uploader(&quot;Upload a CSV file&quot;)</pre><pre>if uploaded_file:<br>    st.write(&quot;File uploaded successfully&quot;)</pre><p>Restrict formats:</p><pre>uploaded_file = st.file_uploader(<br>    &quot;Upload&quot;,<br>    type=[&quot;csv&quot;, &quot;txt&quot;]<br>)</pre><p>Read CSV:</p><pre>import pandas as pd</pre><pre>if uploaded_file:<br>    df = pd.read_csv(uploaded_file)<br>    st.dataframe(df)</pre><p>This is extremely useful in biomedical pipelines.</p><h3>Sidebar</h3><p>The sidebar improves organization.</p><pre>st.sidebar.title(&quot;Settings&quot;)</pre><pre>threshold = st.sidebar.slider(<br>    &quot;Threshold&quot;,<br>    0.0,<br>    1.0,<br>    0.5<br>)</pre><pre>st.write(&quot;Selected threshold:&quot;, threshold)</pre><p>Good for:</p><ul><li>hyperparameters</li><li>filters</li><li>model settings</li></ul><h3>Session State</h3><p>Normally, Streamlit reruns everything after interaction.</p><p>To preserve values:</p><pre>if &quot;counter&quot; not in st.session_state:<br>    st.session_state.counter = 0</pre><pre>if st.button(&quot;Increment&quot;):<br>    st.session_state.counter += 1</pre><pre>st.write(st.session_state.counter)</pre><p>This is essential for stateful apps.</p><h3>Caching</h3><p>Useful for expensive computations.</p><pre>@st.cache_data<br>def load_data():<br>    return &quot;Data loaded&quot;</pre><pre>data = load_data()<br>st.write(data)</pre><p>Benefits:</p><ul><li>faster execution</li><li>reduced repeated computation</li></ul><p>Especially useful for ML models.</p><h3>Complete Example</h3><pre>import streamlit as st<br>import pandas as pd<br>import matplotlib.pyplot as plt</pre><pre>st.title(&quot;Signal Visualizer&quot;)</pre><pre>uploaded_file = st.file_uploader(<br>    &quot;Upload CSV&quot;,<br>    type=[&quot;csv&quot;]<br>)</pre><pre>if uploaded_file:<br>    df = pd.read_csv(uploaded_file)</pre><pre>    st.dataframe(df)</pre><pre>    column = st.selectbox(<br>        &quot;Select signal column&quot;,<br>        df.columns<br>    )</pre><pre>    fig, ax = plt.subplots()<br>    ax.plot(df[column])</pre><pre>    st.pyplot(fig)</pre><p>This simple app can visualize:</p><ul><li>ECG</li><li>EMG</li><li>EEG</li><li>accelerometer signals</li></ul><h3>Deploy Your App</h3><p>You can deploy easily with:</p><h4>Streamlit Cloud</h4><ul><li>Push your code to GitHub.</li><li>Then connect it with: Streamlit Community Cloud</li></ul><h3>Final Thoughts</h3><p>Streamlit is one of the fastest ways to build interactive technical applications.</p><p>Its main strength is abstraction:</p><p>you focus on logic, not web infrastructure.</p><p>For researchers, engineers, and ML developers, this drastically reduces prototyping time.</p><p>If you already work with:</p><ul><li>Python</li><li>Data Science</li><li>Machine Learning</li><li>Signal Processing</li><li>Biomedical Informatics</li></ul><p>learning Streamlit is a high-leverage skill.</p><p>Next steps:</p><ul><li>Connect a TensorFlow model</li><li>Build a real-time sensor dashboard</li><li>Create an image classification app</li><li>Deploy biomedical AI models</li></ul><p>And all of that starts with a single line:</p><pre>streamlit run app.py</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67817fae4f32" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Requirements to Architecture: A Practical Roadmap for Software System Design]]></title>
            <link>https://medium.com/@moises.meza/from-requirements-to-architecture-a-practical-roadmap-for-software-system-design-873a0048c953?source=rss-4a1f1f4dd7a8------2</link>
            <guid isPermaLink="false">https://medium.com/p/873a0048c953</guid>
            <dc:creator><![CDATA[Moises Meza]]></dc:creator>
            <pubDate>Tue, 16 Jun 2026 15:16:02 GMT</pubDate>
            <atom:updated>2026-06-16T15:16:02.747Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tf4dbjm8hF2vV3vz9bAP2A.png" /></figure><p>Designing a successful software system requires more than writing code. It involves a structured process that starts with understanding stakeholder needs and ends with a well-documented, validated architecture. Several established methodologies and standards can help guide this journey. This article provides a practical overview of four important approaches: <strong>Software Requirements Specification (SRS)</strong>, <strong>ATAM</strong>, <strong>ISO/IEC/IEEE 42010</strong>, and the <strong>4+1 Architectural View Model</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YFaiqIKfmiExYh4D7ERRSA.png" /></figure><h3>1. Software Requirements Specification (SRS)</h3><p>The <strong>Software Requirements Specification (SRS)</strong> is the foundation of any software project. It defines what the system must do and the constraints under which it must operate.</p><h3>Purpose</h3><p>The SRS serves as a formal agreement between stakeholders, developers, architects, testers, and project managers. It ensures that everyone shares the same understanding of the system requirements before design and implementation begin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I1mOuqwZT4nWhmwX8Wflng.png" /></figure><h3>Key Components</h3><h3>Functional Requirements</h3><p>Describe the services and behaviors the system must provide.</p><p>Examples:</p><ul><li>User registration and authentication</li><li>Report generation</li><li>Data synchronization</li><li>Payment processing</li></ul><h3>Non-Functional Requirements</h3><p>Define quality attributes and operational constraints.</p><p>Examples:</p><ul><li>Performance</li><li>Scalability</li><li>Security</li><li>Availability</li><li>Usability</li><li>Maintainability</li></ul><h3>Business Rules</h3><p>Specify organizational policies and domain constraints.</p><h3>External Interfaces</h3><p>Describe interactions with:</p><ul><li>Users</li><li>External systems</li><li>APIs</li><li>Hardware devices</li></ul><h3>Benefits</h3><ul><li>Reduces ambiguity</li><li>Improves communication</li><li>Supports traceability</li><li>Provides a baseline for architecture and testing</li></ul><h3><strong>Schedule</strong></h3><p>Initial Review:</p><ul><li>Timing: Before development</li><li>Activities: Stakeholder workshops, requirement validation</li></ul><p>Sprint Reviews:</p><ul><li>Timing: Every 2–4 weeks</li><li>Activities: Check feature alignment, adjust scope</li></ul><p>Milestone Reviews:</p><ul><li>Timing: Major phases</li><li>Activities: Conduct thorough requirement assessments</li></ul><h3><strong>Development of an architecture</strong></h3><p>After knowing the path that you have to follow, it is now time to propose an architecture for the system. So, here you have many designs that you can use; in that sense, you need to select one of them to ensure that the criterion of the requirement is fulfilled.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VlsyZyBWqr6fgH0Q0kASrA.png" /></figure><p>You can use UML diagrams to make more effective schematics:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BV0KMFkMT_QpdxIp8pQQfQ.png" /><figcaption>Example take of the PyQt logic</figcaption></figure><p>Some interesting links:</p><ul><li><a href="https://roadmap.sh/software-design-architecture">https://roadmap.sh/software-design-architecture</a></li><li><a href="https://roadmap.sh/backend">https://roadmap.sh/backend</a></li></ul><h3>2. Architecture Tradeoff Analysis Method (ATAM)</h3><p>Once requirements are defined, architects must determine whether their architectural decisions will satisfy critical quality attributes. This is where <strong>ATAM</strong> becomes valuable.</p><p>ATAM, developed by the Software Engineering Institute, is a structured methodology for evaluating software architectures.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rT7s59ZPmjTRGOHZEhMNUg.png" /></figure><h3>Purpose</h3><p>ATAM helps identify:</p><ul><li>Architectural risks</li><li>Sensitivity points</li><li>Trade-offs between quality attributes</li><li>Potential design weaknesses before implementation</li></ul><h3>Core Idea</h3><p>Every architectural decision has consequences.</p><p>For example:</p><p>DecisionPositive ImpactNegative ImpactMicroservicesScalabilityIncreased complexityCachingPerformanceData consistency challengesEncryptionSecurityPerformance overhead</p><p>ATAM systematically evaluates these trade-offs.</p><h3>Typical Process</h3><h4>Step 1: Present Business Drivers</h4><p>Identify:</p><ul><li>Business goals</li><li>Critical requirements</li><li>Constraints</li></ul><h4>Step 2: Present Architecture</h4><p>Architects explain the proposed solution.</p><h4>Step 3: Generate Quality Attribute Scenarios</h4><p>Examples:</p><ul><li>The system must support 50,000 concurrent users.</li><li>Recovery must occur within 30 seconds after a failure.</li><li>New features should be deployable without downtime.</li></ul><h4>Step 4: Analyze Architectural Approaches</h4><p>Evaluate how architectural decisions support or hinder these scenarios.</p><h4>Step 5: Identify Risks and Trade-Offs</h4><p>Document areas that require further attention.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b6g9kGklhJ3GdYOVgSO3Jg.png" /></figure><h3>Benefits</h3><ul><li>Early risk detection</li><li>Better decision-making</li><li>Improved stakeholder alignment</li><li>Stronger architecture validation</li></ul><h3>3. ISO/IEC/IEEE 42010</h3><p>While SRS defines requirements and ATAM evaluates architecture, organizations also need a standard way to describe and document architectural decisions.</p><p>This is the role of <strong>ISO/IEC/IEEE 42010</strong>.</p><h3>Purpose</h3><p>The standard provides guidance for:</p><ul><li>Architecture descriptions</li><li>Stakeholder concerns</li><li>Architectural viewpoints</li><li>Architectural documentation</li></ul><h3>Key Concepts</h3><h3>Stakeholders</h3><p>Anyone with an interest in the system:</p><ul><li>End users</li><li>Developers</li><li>Operations teams</li><li>Managers</li><li>Regulators</li></ul><h3>Concerns</h3><p>Questions stakeholders need answered:</p><ul><li>Is the system secure?</li><li>Can it scale?</li><li>Is it maintainable?</li></ul><h3>Viewpoints</h3><p>A viewpoint defines how specific concerns are addressed.</p><h3>Views</h3><p>Actual architectural representations created using a viewpoint.</p><h3>Why It Matters</h3><p>Many software failures are caused not by poor technology but by poor communication. ISO 42010 provides a common language for documenting and communicating architecture.</p><h3>Benefits</h3><ul><li>Improved architectural governance</li><li>Consistent documentation</li><li>Better communication across teams</li><li>Alignment between architecture and stakeholder needs</li></ul><h3>4. The 4+1 Architectural View Model</h3><p>Proposed by Philippe Kruchten, the <strong>4+1 View Model</strong> offers a practical framework for describing software architecture from multiple perspectives.</p><p>Different stakeholders need different architectural information.</p><p>A developer and a system administrator rarely care about the same details.</p><p>The 4+1 model addresses this challenge.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a59Cp7PnHPU3OaChanCXTQ.png" /></figure><p><a href="https://en.wikipedia.org/wiki/4%2B1_architectural_view_model#/media/File:4+1_Architectural_View_Model.svg">4+1 architectural view model - Wikipedia</a></p><h3>1. Logical View</h3><p>Focuses on functionality.</p><p>Answers:</p><ul><li>What are the major components?</li><li>How do business concepts relate?</li></ul><p>Common diagrams:</p><ul><li>Class diagrams</li><li>Domain models</li><li>Component diagrams</li></ul><p>Audience:</p><ul><li>Business analysts</li><li>Architects</li><li>Developers</li></ul><h3>2. Development View</h3><p>Focuses on software organization.</p><p>Answers:</p><ul><li>How is the code structured?</li><li>How are modules organized?</li></ul><p>Common artifacts:</p><ul><li>Package structures</li><li>Repositories</li><li>Component organization</li></ul><p>Audience:</p><ul><li>Developers</li><li>Technical leads</li></ul><h3>3. Process View</h3><p>Focuses on runtime behavior.</p><p>Answers:</p><ul><li>How do components communicate?</li><li>How is concurrency managed?</li><li>How are performance requirements achieved?</li></ul><p>Common diagrams:</p><ul><li>Sequence diagrams</li><li>Process diagrams</li><li>Communication flows</li></ul><p>Audience:</p><ul><li>Architects</li><li>Performance engineers</li></ul><h3>4. Physical View</h3><p>Focuses on deployment infrastructure.</p><p>Answers:</p><ul><li>Where is the system deployed?</li><li>How are servers connected?</li><li>What infrastructure is required?</li></ul><p>Common diagrams:</p><ul><li>Deployment diagrams</li><li>Cloud architecture diagrams</li><li>Network topology diagrams</li></ul><p>Audience:</p><ul><li>DevOps teams</li><li>Infrastructure engineers</li></ul><h3>+1. Scenario View</h3><p>The “plus one” view validates all other views using use cases and scenarios.</p><p>Examples:</p><ul><li>User login</li><li>Order processing</li><li>Real-time monitoring</li><li>Disaster recovery</li></ul><p>This view demonstrates that the architecture can successfully support real-world requirements.</p><p>Audience:</p><ul><li>All stakeholders</li></ul><h3>Putting Everything Together: A Practical Workflow</h3><p>These methodologies are most effective when used together.</p><pre>1. Gather Stakeholder Needs<br>           ↓<br>2. Create SRS<br>   - Functional Requirements<br>   - Non-Functional Requirements<br>           ↓<br>3. Design Initial Architecture<br>           ↓<br>4. Document Architecture<br>   Using ISO/IEC/IEEE 42010<br>           ↓<br>5. Describe Architecture<br>   Using the 4+1 View Model<br>           ↓<br>6. Validate Architecture<br>   Using ATAM<br>           ↓<br>7. Refine and Iterate<br>           ↓<br>8. Implementation</pre><h3>Conclusion</h3><p>Software architecture is not a single activity but a disciplined process that transforms requirements into a robust and maintainable system.</p><p>A practical architecture workflow can be summarized as follows:</p><ul><li><strong>SRS</strong> defines what the system must do.</li><li><strong>ISO/IEC/IEEE 42010</strong> defines how architecture should be documented.</li><li><strong>4+1 View Model</strong> provides multiple perspectives to describe the architecture.</li><li><strong>ATAM</strong> evaluates whether the architecture can satisfy critical quality attributes and business goals.</li></ul><p>Together, these methodologies create a powerful framework for designing software systems that are understandable, scalable, maintainable, and aligned with stakeholder expectations. They help teams move from vague ideas to well-engineered solutions with a clear architectural rationale.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=873a0048c953" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Adiós pip, Hola uv: La Guía Definitiva del Nuevo Estándar en Python]]></title>
            <link>https://medium.com/@moises.meza/adi%C3%B3s-pip-hola-uv-la-gu%C3%ADa-definitiva-del-nuevo-est%C3%A1ndar-en-python-e95f2c32b662?source=rss-4a1f1f4dd7a8------2</link>
            <guid isPermaLink="false">https://medium.com/p/e95f2c32b662</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[uv]]></category>
            <dc:creator><![CDATA[Moises Meza]]></dc:creator>
            <pubDate>Mon, 15 Jun 2026 20:42:53 GMT</pubDate>
            <atom:updated>2026-06-15T20:42:53.503Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QzIxDWFG_Mf-Q_0vcmUbEQ.png" /></figure><p>Si llevas tiempo programando en Python, seguramente has lidiado con el dolor de cabeza que supone gestionar entornos virtuales y dependencias. Entre pip, virtualenv, poetry y pipenv, el ecosistema puede volverse un caos. Pero todo eso está a punto de cambiar.</p><p>Hoy vamos a hablar de uv, una de las herramientas más emocionantes y revolucionarias que han llegado al ecosistema de Python recientemente. Creada por Astral (los mismos desarrolladores del popular linter Ruff), está escrita en Rust y es increíblemente rápida, alcanzando velocidades de 10 a 100 veces mayores que el pip tradicional.</p><p>Lo mejor de todo es que uv es un &quot;todo en uno&quot;: reemplaza a pip, virtualenv, pip-tools e incluso a gestores más complejos. En esta guía, te enseñaré cómo dominarlo desde cero.</p><h3>1. Instalación Global</h3><p>El primer paso es instalar uv. Lo ideal es instalarlo como una herramienta global en tu sistema, totalmente independiente de cualquier versión específica de Python que tengas.</p><p>Abre tu terminal y ejecuta el comando según tu sistema operativo:</p><pre>pip install uv # forma general</pre><p><strong>Windows (PowerShell):</strong></p><p>PowerShell</p><pre>powershell -ExecutionPolicy ByPass -c &quot;irm https://astral.sh/uv/install.ps1 | iex&quot;</pre><p><strong>macOS / Linux:</strong></p><p>Bash</p><pre>curl -LsSf https://astral.sh/uv/install.sh | sh</pre><h3>2. El Flujo de Trabajo Moderno (Recomendado)</h3><p>Esta es la mejor manera de usar uv si vas a empezar un proyecto desde cero. Es súper limpio porque te olvidas por completo de tener que activar entornos virtuales manualmente.</p><p><strong>Paso A: Iniciar el proyecto</strong> Ve a tu carpeta de trabajo y ejecuta:</p><p>Bash</p><pre>uv init mi_nuevo_proyecto<br>cd mi_nuevo_proyecto</pre><p>Esto te creará una estructura básica con un archivo pyproject.toml. Si ya sabes qué versión exacta de Python necesitas (por ejemplo, la 3.12), puedes usar directamente uv init --python 3.12 mi_nuevo_proyecto.</p><p><strong>Paso B: Añadir paquetes</strong> Olvídate de pip install. Ahora usamos uv add.</p><p>Bash</p><pre>uv add pandas requests</pre><p>Esto no solo descarga los paquetes a la velocidad del rayo y los anota en tu configuración, sino que crea el entorno virtual de fondo automáticamente. ¡Incluso descargará la versión de Python necesaria por ti si no la tienes instalada en tu sistema!</p><p><strong>Paso C: Ejecutar el código.</strong> Aquí viene la verdadera magia. No necesitas ejecutar source .venv/bin/activate. Solo usa:</p><p>Bash</p><pre>uv run main.py</pre><p>También puedes hacer esto:</p><pre>uv run python main.py    # uv run python --version</pre><p>uv detecta automáticamente tu entorno virtual y lo usa para ejecutar el archivo.</p><h3>3. El Flujo de Trabajo Clásico</h3><p>Si ya tienes un proyecto existente o prefieres trabajar a la antigua, uv funciona como un reemplazo directo (drop-in replacement).</p><ul><li>Crea tu entorno: uv venv.</li><li>Actívalo normalmente: .venv\Scripts\activate (Windows) o source .venv/bin/activate (Mac/Linux).</li><li>Instala paquetes añadiendo uv antes del comando habitual: uv pip install numpy.</li></ul><p><em>⚠️ Cuidado con mezclar métodos:</em> Si usaste uv init (método moderno), no uses uv pip install sin antes haber creado el entorno; la herramienta te dará un error esperando un entorno ya creado. Usa siempre uv add en el flujo moderno.</p><h3>4. Trabajo en Equipo y GitHub: El poder de uv.lock</h3><p>Llevar tu proyecto a otra computadora o compartirlo con tu equipo nunca ha sido tan fácil. El secreto de uv es un archivo que se genera automáticamente llamado uv.lock, el cual guarda las versiones exactas de todas tus librerías.</p><ul><li>Asegúrate de ignorar la carpeta .venv en tu .gitignore para no subir miles de archivos pesados a GitHub.</li><li>Sube tus archivos (pyproject.toml y uv.lock) a tu repositorio.</li><li>En la nueva computadora, simplemente clona el repositorio y ejecuta:</li></ul><p>Bash</p><pre>uv sync</pre><p>Al hacer esto, uv creará la carpeta .venv, descargará la versión correcta de Python si es necesario, e instalará las versiones exactas de tus librerías para que todo sea un clon perfecto del original.</p><p><strong>💡 Un Tip Pro para Git:</strong> Para facilitarte la vida, uv init crea automáticamente una carpeta oculta .git asumiendo que es un proyecto desde cero. Si estás creando un proyecto de uv <em>dentro</em> de una carpeta que ya es un repositorio de Git, esto te causará un error porque Git se confunde con los repositorios anidados. Para evitarlo, inicia tu proyecto así:</p><p>Bash</p><pre>uv init --no-git mi_proyecto</pre><p>De esta forma, crearás tu estructura sin conflictos.</p><h3>5. Caché Global: Ahorra espacio en tu disco</h3><p>Finalmente, una de mis características favoritas: la <strong>Caché Global</strong>. Si ya instalaste una librería en otro proyecto usando uv, cuando la instales en uno nuevo, uv no la volverá a descargar; simplemente creará un enlace a los archivos que ya tienes en tu disco.</p><p>Para eliminar un proyecto, solo tienes que borrar su carpeta de tu computadora. Si alguna vez quieres recuperar espacio real en disco vaciando esta memoria global, solo ejecuta uv cache clean.</p><h3>Conclusión</h3><p>uv no es solo una herramienta rápida; es un rediseño completo de cómo deberíamos gestionar dependencias y versiones de Python, aplicando las mejores prácticas modernas de desarrollo. Si empiezas un proyecto hoy, dale una oportunidad. Te aseguro que no querrás volver atrás.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e95f2c32b662" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Docker from Zero to Hero ]]></title>
            <link>https://medium.com/@moises.meza/docker-from-zero-to-hero-bc7afa8977fa?source=rss-4a1f1f4dd7a8------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc7afa8977fa</guid>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Moises Meza]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 01:55:21 GMT</pubDate>
            <atom:updated>2026-08-07T21:21:57.356Z</atom:updated>
            <content:encoded><![CDATA[<p>A practical, engineer-oriented guide to understanding and using Docker — from first principles to real-world workflows (with common mistakes and fixes).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*le1-x2LXJnAsdReq--ElEA.png" /></figure><h3>1. Why Docker Exists</h3><p>If you have ever faced:</p><ul><li>“It works on my machine”</li><li>dependency conflicts</li><li>painful environment setup</li></ul><p>Docker solves this by packaging applications into <strong>containers</strong>.</p><h3><strong>INSTALL</strong></h3><p>To install Docker Desktop for your Mac, Linux, or Windows:<a href="https://docs.docker.com/desktop/">https://docs.docker.com/desktop/</a></p><p>To install Docker on UBUNTU: <a href="https://docs.docker.com/engine/install/ubuntu/">https://docs.docker.com/engine/install/ubuntu/</a></p><h3>Core idea:</h3><ul><li><strong>Image</strong> → blueprint (immutable)</li><li><strong>Container</strong> → running instance (mutable)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kcOxN5VsHsBqYO6t7Bv3Pg.png" /></figure><h3>2. Installing and Verifying Docker</h3><p>After installation, always verify:</p><pre>$ docker --version<br>$ docker run hello-world #pull an image and run it, it is just for verifying</pre><p>If hello-world runs → your setup is correct.</p><h3>Listing Images</h3><p>To see downloaded images:</p><pre>$ docker images</pre><p>Advanced:</p><pre>$ docker images -a<br>$ docker images -q</pre><h3>Inspecting Containers</h3><pre>$ docker ps         # listar las imágenes activas<br>$ docker ps -a      # listar las imágenes inactivas</pre><h3>Disk usage analysis (very useful)</h3><pre>$ docker system df</pre><p>Example output:</p><pre>TYPE            TOTAL     ACTIVE    SIZE<br>Images          5         2         1.2GB<br>Containers      2         1         50MB<br>Volumes         3         1         300MB</pre><h3>Inspect where Docker stores data (safe method)</h3><p>Instead of browsing the filesystem, use:</p><pre>$ docker info</pre><h3>######## BASIC USE OF DOCKER ###########</h3><p>You can download a public image that will be helpful for creating a container.</p><pre>$ docker pull ubuntu   # download an image<br>$ docker docker -it ubuntu bash   # create a container<br>&gt;&gt; exit</pre><p>Identify the ID or the name:</p><pre>$ docker ps -a</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/927/1*0M-QwZSgEYn-39F3sAEkfw.png" /></figure><p>Then init:</p><pre>$ docker start 8630337ab711</pre><p>Enter again:</p><pre>$ docker exec -it 8630337ab711 bash<br><br>$ docker rm 8630337ab711   # Remove containe</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tP0kkFRONIOsqHfLnxsq2A.png" /></figure><h3><strong>NAME A CONTAINER: Useful workflow for using a container</strong></h3><pre># Create the container with a specific name el contenedor<br>docker run --name laboratorio -it ubuntu bash<br><br># get out from BASH <br>  &gt;&gt; exit<br><br># See the containers if &quot;laboratorio&quot; is active<br>docker ps -a  # check all container inactives<br><br># Useful to see compact: <br># docker ps -a --format &quot;table {{.Names}}\t{{.Image}}\t{{.Status}}&quot;<br><br># IF &quot;laboratorio&quot; is not active then Get up the container<br>docker start laboratorio<br><br># Enter again after getting out<br>docker exec -it laboratorio bash<br><br># Stop (from other terminal)<br>docker stop laboratorio<br><br># remove the container if it has not an use<br>docker rm laboratorio</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kIQHUcWXpNPYloIucJpPAQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fz-dOnrkmj4arKYcCfpfeQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*puMEBtdywPLGu6RK5F5GAQ.png" /></figure><h3>Clean unused images</h3><p>To remove unused images:</p><pre>$ docker image prune</pre><p>More aggressive:</p><pre>$ docker image prune -a<br><br># Remove a specific image:<br>$ docker rmi &lt;image_name&gt;:&lt;tag&gt; (e.g., docker rmi ubuntu:latest)<br>$ docker rmi &lt;image_id&gt; (You can get the ID using docker images)<br><br><br># Force remove an image (even if in use by a container):<br>$ docker rmi -f &lt;image_name_or_id&gt;<br><br><br># Remove multiple images at once:<br>$ docker rmi &lt;image_id_1&gt; &lt;image_id_2&gt; ...</pre><p><strong>Resume of useful commands</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*24oo5DFAXWrglxx9kR96kA.png" /></figure><h3>3. First Concepts You Must Understand</h3><h3>docker pull nginx</h3><p>👉 This <strong>downloads an image</strong>, NOT a container.</p><p>Then:</p><pre>$ docker pull nginx  $ download the image<br>$ docker run nginx  # to run the container based on the image</pre><p>👉 This creates and runs a <strong>container from that image</strong>.</p><h3>Key takeaway:</h3><ul><li>docker pull → image</li><li>docker run → container</li></ul><h3>4. Where Do Images Come From?</h3><p>Docker pulls images from <strong>public registries</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ezk7EDvLmjQIwh8y7JkxEg.png" /></figure><h3>Default registry:</h3><p>👉 Docker Hub (<a href="https://hub.docker.com/">https://hub.docker.com</a>)</p><p>Example:</p><pre>$ docker pull nginx</pre><p>Internally resolves to:</p><pre>docker.io/library/nginx:latest</pre><h3>Where Are Images Stored Locally?</h3><p>On Linux:</p><pre>/var/lib/docker/</pre><p>Important subdirectories:</p><pre>overlay2/   → actual layers<br>image/      → metadata<br>volumes/    → persistent data</pre><p>⚠️ Never modify this manually.</p><h3>5. Running Your First Real Service (Node-RED)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HMeiKWjHm6DRID8oJZ3zfw.png" /></figure><p>Example, you tried:</p><pre>$ sudo docker pull nodered/node-red:latest<br>$ sudo docker run nodered/node-red:latest</pre><p>And saw:</p><pre>Server running at http://127.0.0.1:1880</pre><p>But the browser showed:</p><pre>127.0.0.1 refused to connect</pre><h3>Why It Failed (Critical Concept)</h3><p>Docker isolates networking. So:</p><pre>container localhost ≠ your machine localhost</pre><h3>Fix: Port Mapping</h3><p>Correct command:</p><pre>$ sudo docker run -it -p 1880:1880 nodered/node-red:latest</pre><h3>What this means:</h3><pre>HOST:1880 → CONTAINER:1880</pre><p>Now access:<br>👉 <a href="http://localhost:1880/">http://localhost:1880</a></p><h3>Persisting Data (Volumes)</h3><p>You used:</p><pre>-v node_red_data:/data</pre><h3>Question:</h3><blockquote><em>Where is </em><em>node_red_data located?</em></blockquote><p>Answer:</p><pre>/var/lib/docker/volumes/node_red_data/_data</pre><p>This is a <strong>named volume</strong> managed by Docker.</p><h3>6. Using Your Own Folder (Better for Development)</h3><p>Instead of a Docker-managed volume:</p><pre>-v node_red_data:/data</pre><p>Use a <strong>bind mount</strong>:</p><pre>-v /home/stevend/nodered-data:/data</pre><p>Now:</p><pre>/data (container) → /home/stevend/nodered-data (host)</pre><h3>Common Error: Permission Denied</h3><p>You encountered:</p><pre>EACCES: permission denied</pre><h3>Root cause:</h3><ul><li>container runs as UID 1000</li><li>Your folder belongs to root</li></ul><h3>Fix Permissions</h3><pre>$ sudo chown -R 1000:1000 /home/stevend/nodered-data</pre><p>Then rerun:</p><pre>$ sudo docker run -it \<br>  -p 1880:1880 \<br>  -v /home/stevend/nodered-data:/data \<br>  --name my_nodered \<br>  nodered/node-red:latest</pre><h3>7. Understanding Volumes vs Bind Mounts</h3><ul><li>volumenode_red_data:/data , you need to create a just use the name</li><li>bind mount/home/...:/data: you have to specify the path</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pQubN-N9WC789o1WIRrKwA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RfbO71XUXTni-CFntWIy3g.png" /></figure><h3>8. One compact real example</h3><p>Here is a minimal app you can copy.</p><h4>app.py</h4><pre>from flask import Flask<br>app = Flask(__name__)</pre><pre>@app.route(&quot;/&quot;)<br>def home():<br>    return &quot;Docker works&quot;</pre><pre>if __name__ == &quot;__main__&quot;:<br>    app.run(host=&quot;0.0.0.0&quot;, port=5000)</pre><h3>requirements.txt</h3><pre>flask==3.0.0</pre><h3>Dockerfile</h3><pre>FROM python:3.11-slim<br>WORKDIR /app<br>COPY requirements.txt .<br>RUN pip install --no-cache-dir -r requirements.txt<br>COPY . .<br>CMD [&quot;python&quot;, &quot;app.py&quot;]</pre><h3>Build and run</h3><pre>$ docker build -t docker-hello .<br>$ docker run -d -p 5000:5000 --name docker-hello-container docker-hello</pre><p>Then open:</p><pre>http://localhost:5000</pre><h3>9. ¿Qué es un Dockerfile?</h3><p>Un <strong>Dockerfile</strong> es un archivo de texto que define cómo construir una imagen.</p><p>👉 Especifica:</p><ul><li>imagen base</li><li>dependencias</li><li>configuración</li><li>comando de ejecución</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*guTP3wQyZ5hgWdCvvtnACA.png" /></figure><h3>Crear un Dockerfile</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b_liALOpxURjcvlbH2LdBA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ymjdCc29eCJHS-_wxRtrkg.png" /></figure><h3>Opción básica</h3><pre>touch Dockerfile</pre><p>Luego lo editas:</p><pre>nano Dockerfile</pre><h3>Ejemplo mínimo</h3><pre># Imagen base<br>FROM python:3.11<br># Directorio de trabajo<br>WORKDIR /app<br># Copiar archivos<br>COPY . .<br># Instalar dependencias<br>RUN pip install flask<br># Comando por defecto<br>CMD [&quot;python&quot;, &quot;app.py&quot;]</pre><h3>Estructura conceptual</h3><pre>FROM → base<br>RUN → instala cosas<br>COPY → mete archivos<br>WORKDIR → contexto<br>CMD → qué ejecutar</pre><h3>rear una imagen</h3><p>Una vez tengas el Dockerfile:</p><pre>docker build -t name_of_imagen .</pre><p>Donde:</p><ul><li>-t → nombre de la imagen</li><li>. → contexto (directorio actual)</li></ul><h3>Ver imágenes</h3><pre>docker images</pre><h3>Dockerfile con otro nombre</h3><p>Sí, puedes usar cualquier nombre:</p><pre>touch Dockerfile.dev</pre><h3>Construir con nombre personalizado</h3><pre>docker build -f Dockerfile.dev -t mi_imagen .</pre><p>Esto es clave en entornos reales.</p><h3><strong>Naming Conventions</strong></h3><p>While the default name is Dockerfile (no extension), you can use the .dockerfile extension, particularly when you need multiple Dockerfiles in a single project directory (e.g., dev.dockerfile, prod.dockerfile).</p><p>GeeksforGeeks</p><ul><li><strong>Dockerfile</strong>: The default and recommended name for the primary Dockerfile in a project. This allows you to use the docker build command without additional flags.</li><li><strong>&lt;name&gt;.dockerfile</strong>: A common convention for specific or alternative Dockerfiles. When using this convention, you must specify the filename with the --file (or -f) flag in the docker build command (e.g., docker build --file dev.dockerfile .).</li></ul><h3>Ejemplo real (tu contexto: GPU + ML)</h3><p>En Hinton se usa algo así:</p><pre># Crear un dockerfile con este nombre<br><br>$ touch dockerfile_python.dockerfile<br><br># O puedes crearlo desde vscode</pre><pre>#FROM pytorch/pytorch:2.3.0-cuda12.1-cudnn8-runtime<br>FROM python:3.11<br>WORKDIR /workspace<br>RUN pip install numpy pandas matplotlib  jupyterlab notebook<br>EXPOSE 8888<br>CMD [&quot;jupyter&quot;, &quot;lab&quot;, &quot;--ip=0.0.0.0&quot;, &quot;--port=8888&quot;, &quot;--no-browser&quot;, &quot;--allow-root&quot;,  &quot;--NotebookApp.token=&#39;&#39;&quot;]</pre><h3>Build:</h3><pre>$ docker build -f .\dockerfile_python.dockerfile -t ml_jupyter .</pre><h3>Ejecutar la imagen</h3><pre>$ docker run -it ml_jupyter<br><br># si quiere revisar su bash<br>$ docker run -it ml_jupyter bash</pre><p>O con puertos:</p><pre>$ docker run -it -p 8888:8888 ml_jupyter</pre><h3>Flujo completo</h3><pre>Dockerfile → docker build → imagen → docker run → contenedor<br><br># resumen<br><br>  44 docker rmi -f ml_jupyter:latest<br>  47 docker rm -f b49152853333<br>  48 docker ps<br>  49 docker ps -a<br>  50 docker images<br>  51 docker build -f .\dockerfile_python.dockerfile -t ml_jupyter .<br>  52 docker run -it -p 8888:8888 ml_jupyter<br>  54 docker start 15c2a37f9fb9<br>  55 docker stop 15c2a37f9fb9</pre><h3>Buenas prácticas (nivel ingeniería)</h3><h3>Minimizar tamaño</h3><ul><li>Usa imágenes slim</li><li>evita instalar cosas innecesarias</li></ul><h4>Cache de capas</h4><p>Ordena así:</p><pre>COPY requirements.txt .<br>RUN pip install -r requirements.txt<br>COPY . .</pre><h4>Control de GPU (muy importante para ti)</h4><p>En entornos como Hinton:</p><pre>docker run --gpus all ...</pre><p>Y en TensorFlow:</p><ul><li>usar memory growth</li><li>limitar VRAM<br> (esto evita saturación de recursos compartidos)</li></ul><h3>RESUME: completo paso a paso</h3><h4>Crear proyecto</h4><pre>mkdir mi_app<br>cd mi_app<br>touch Dockerfile app.py</pre><h4>Dockerfile</h4><pre>FROM python:3.11<br>WORKDIR /app<br>COPY . .<br>RUN pip install flask<br>CMD [&quot;python&quot;, &quot;app.py&quot;]</pre><h4>app.py</h4><pre>print(&quot;Hello Docker&quot;)</pre><h4>Build</h4><pre>docker build -t mi_app .</pre><h4>Run</h4><pre>docker run mi_app</pre><h4>Comandos clave resumen</h4><pre>docker build -t nombre .<br>docker build -f Dockerfile.dev -t nombre .<br>docker images<br>docker run nombre<br>docker rmi nombre</pre><h3>10. Docker Compose (Next Step)</h3><p><strong>Docker Compose</strong> is a tool that lets you <strong>define, run, and manage multi-container applications using a single configuration file</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3NsqihHpcpoxmL23te6amg.png" /></figure><p>Instead of multiple commands:</p><pre>docker run ...<br>docker run ...<br>docker run ...</pre><p>Use:</p><pre>services:<br>  nodered:<br>    image: nodered/node-red<br>    ports:<br>      - &quot;1880:1880&quot;</pre><pre>  mqtt:<br>    image: eclipse-mosquitto</pre><pre>  db:<br>    image: postgres:16</pre><p>Then:</p><pre>$ docker compose up</pre><h3>From Zero to Hero — What You Achieved</h3><p>By following this:</p><p>✔️ You understand images vs containers<br>✔️ You debugged networking issues<br>✔️ You fixed permission problems<br>✔️ You used volumes correctly<br>✔️ You exposed services properly</p><h3>Final Advice</h3><p>Docker is not learned by reading — it is learned by <strong>running, breaking, and fixing systems</strong>.</p><p>The fastest path to mastery is:</p><ol><li>Run containers</li><li>Break something</li><li>Debug it</li><li>Repeat</li></ol><p>If you reached this point, you are no longer a beginner — you are already operating at an intermediate level.</p><p>🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc7afa8977fa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Working with Independent Branches in Git: Creating an Orphan Branch for a Completely Different…]]></title>
            <link>https://medium.com/@moises.meza/working-with-independent-branches-in-git-creating-an-orphan-branch-for-a-completely-different-ae443c1db322?source=rss-4a1f1f4dd7a8------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae443c1db322</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[ophan-branch]]></category>
            <dc:creator><![CDATA[Moises Meza]]></dc:creator>
            <pubDate>Wed, 04 Mar 2026 21:25:02 GMT</pubDate>
            <atom:updated>2026-03-04T21:25:02.414Z</atom:updated>
            <content:encoded><![CDATA[<h3>Working with Independent Branches in Git: Creating an Orphan Branch for a Completely Different Project</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6aisTqgGimf0ABmeWq8T3g.png" /></figure><p>Sometimes a single repository needs to host <strong>two completely different projects</strong>. For example:</p><ul><li>A main branch containing the original project.</li><li>A second branch containing <strong>an entirely unrelated project</strong>, with no shared commit history.</li></ul><p>This can be done using <strong>orphan branches in Git</strong>. An orphan branch starts a <strong>new root commit</strong>, meaning its history is independent from the existing branches.</p><p>This guide explains how to create and push an orphan branch, even when the second project already exists on another machine.</p><h3>Why Use an Orphan Branch?</h3><p>An orphan branch is useful when you want:</p><ul><li>Two independent projects inside the same repository</li><li>A branch dedicated to <strong>datasets, experiments, or documentation</strong></li><li>Separate histories for different research or development tracks</li></ul><p>Unlike normal branches, an orphan branch <strong>does not inherit commits</strong> from any other branch.</p><h3>Scenario</h3><p>Suppose you have:</p><ul><li>A repository on GitHub with a branch called main.</li><li>Another computer with a <strong>different project in a folder</strong>.</li><li>You want to push that folder as a <strong>new orphan branch</strong> to the same repository.</li></ul><p>Importantly, you <strong>do not need to clone the repository</strong> and you <strong>do not need to delete your existing files</strong>.</p><h3>Step 1 — Navigate to Your Project Folder</h3><p>Go to the directory containing the project you want to upload.</p><pre>cd /path/to/your/project</pre><h3>Step 2 — Initialize Git</h3><p>Initialize a new Git repository in that folder.</p><pre>$ git init</pre><h3>Step 3 — Create an Orphan Branch</h3><p>Create a new branch with no commit history.</p><pre>$ git checkout --orphan new-branch</pre><p>At this point, the branch exists but has <strong>no commits yet</strong>.</p><h3>Step 4 — Add Your Files</h3><p>Stage all the files in the folder.</p><pre>$ git add .</pre><h3>Step 5 — Create the First Commit</h3><p>Create the initial commit for this independent project.</p><pre>$ git commit -m &quot;Initial commit for orphan branch&quot;</pre><p>This commit becomes the <strong>root of a completely separate history</strong>.</p><h3>Step 6 — Connect to the Remote Repository</h3><p>Add the GitHub repository as the remote origin.</p><pre>$ git remote add origin https://github.com/USERNAME/REPOSITORY.git</pre><p>Verify the remote configuration:</p><pre>$ git remote -v</pre><h3>Step 7 — Push the New Branch</h3><p>Push the orphan branch to the remote repository.</p><pre>$ git push origin new-branch</pre><h3>Result</h3><p>Your repository will now contain two independent branches:</p><pre>main        → original project<br>new-branch  → completely different project</pre><p>Both branches coexist in the same repository, but <strong>their commit histories are unrelated</strong>.</p><h3>Listing All Branches</h3><p>To see all branches locally and remotely:</p><pre>$ git branch -a</pre><p>To see only remote branches:</p><pre>$ git branch -r</pre><h3>Visualizing the Independent Histories</h3><p>You can visualize the commit structure using:</p><pre>$ git log --graph --all</pre><p>You will see two separate commit trees because the orphan branch does not share history with main.</p><h3>Practical Use Cases</h3><p>Developers and researchers often use orphan branches for:</p><ul><li>Large datasets</li><li>Experimental machine learning models</li><li>Documentation</li><li>GitHub Pages</li><li>Independent prototypes within the same repository</li></ul><p>This approach keeps projects organized while maintaining clear and independent histories.</p><h3>Final Thoughts</h3><p>Orphan branches are a powerful but often overlooked Git feature. They allow a repository to host multiple independent projects without mixing commit histories.</p><p>When used carefully, they provide a clean and flexible way to manage different workflows within a single repository.</p><p>If something bad happens, you can try using this way:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/627/1*eOnYoVZ7fC8uwNNZbF9yUA.png" /><figcaption>Do using commands</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HW2a_MRTW8bT9HQRsJr3Dg.png" /><figcaption>then use vscode to link to yougithub account</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae443c1db322" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ First Steps in IoT Part-II: Understanding MQTT the Language of IoT Devices]]></title>
            <link>https://medium.com/@moises.meza/first-steps-in-iot-part-ii-understanding-mqtt-the-language-of-iot-devices-fc5bf998f85b?source=rss-4a1f1f4dd7a8------2</link>
            <guid isPermaLink="false">https://medium.com/p/fc5bf998f85b</guid>
            <dc:creator><![CDATA[Moises Meza]]></dc:creator>
            <pubDate>Sat, 11 Oct 2025 17:11:57 GMT</pubDate>
            <atom:updated>2025-10-11T17:11:57.929Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YpvLZ2Uj73O7wk6a.png" /><figcaption><a href="https://v1-connected-digital-energy-meter.netlify.app/05_mqtt/#mosquitto">https://v1-connected-digital-energy-meter.netlify.app/05_mqtt/#mosquitto</a></figcaption></figure><p>MQTT stands for <strong>Message Queuing Telemetry Transport</strong>. It was created in <strong>1999</strong> by <strong>Andy Stanford-Clark (IBM)</strong> and <strong>Arlen Nipper (Arcom, later Cirrus Link)</strong>. The o<strong>riginal mission was </strong>connect <em>oil pipeline sensors</em> to monitoring systems using <strong>very low bandwidth, unreliable networks</strong>, and <strong>battery-powered embedded devices</strong>.</p><blockquote><em>⚙️ Fun fact: MQTT was designed so small that even </em><strong><em>8-bit microcontrollers</em></strong><em> like Arduino could speak it using only a few kilobytes of RAM.</em></blockquote><h3>🌍 From Oil Pipelines to Smart Homes</h3><p>Today, the same protocol is used in:</p><ul><li><strong>Smart homes:</strong> ESP32 sending temperature to Home Assistant.</li><li><strong>Healthcare devices:</strong> sending wearable sensor readings.</li><li><strong>Industrial IoT:</strong> SCADA systems, predictive maintenance signals.</li><li><strong>MQTT + AI workflows:</strong> send sensor data → store to database → feed to LLM or n8n → create dashboard → trigger alerts.</li></ul><h3>🧠 MQTT in Simple Words</h3><p>Think of MQTT like a <strong>post office</strong>:</p><ul><li><strong>Broker: </strong>Role MQTT Equivalent Post Office (example: Mosquitto)</li><li><strong>Publisher: </strong>Person sending message</li><li><strong>Subscriber: </strong>Person receiving messages</li><li><strong>Topic: </strong>Address to send</li><li><strong>Payload/message: </strong>Message content</li></ul><p>Example:</p><pre>Topic: home/livingroom/temperature<br>Payload: 23.5 °C<br>broker: test.mosquitto.org</pre><ul><li>Anyone <strong>subscribed</strong> to home/livingroom/temperature will <strong>instantly receive</strong> 23.5 °C.</li><li>You <strong>publish once</strong>, multiple devices <strong>receive simultaneously</strong> → <strong>very efficient</strong>.</li></ul><h3>🧩 What is a Broker?</h3><p>A <strong>Broker</strong> is the <strong>central server</strong> that receives and distributes MQTT messages.</p><h3>🏠 Local Broker — Mosquitto (Recommended for Learning)</h3><p>Runs on <strong>Windows / Linux / Raspberry Pi / Docker</strong></p><ul><li>Fast, tiny, open-source.</li><li>Perfect for <strong>testing and local prototyping</strong>.</li><li>URL: mqtt://localhost:1883</li></ul><h3>☁️ Free Online Test Brokers</h3><p>BrokerURL / Info</p><ul><li>test.mosquitto.org: No login, public topics</li><li>HiveMQ Public Brokerbroker.hivemq.com port 1883</li><li>Eclipse Public Brokermqtt.eclipseprojects.io</li></ul><p>💡 For <strong>beginners</strong>, start with:<br> 🔹 localhost using Mosquitto<br> 🔹 then try <strong>HiveMQ</strong>: broker.hivemq.com to test remote IoT-style communication</p><h3>⚙️ Installing Mosquitto (Quick Recap)</h3><ul><li>In <strong>Linux / Ubuntu : </strong>Use this command: sudo apt install mosquitto mosquitto-clients</li><li><strong>For Windows user: </strong>Download from <a href="https://mosquitto.org/download">https://mosquitto.org/download</a></li></ul><p>To check if it’s running:</p><pre>$ mosquitto_sub</pre><pre>$ mosquitto_pub</pre><pre>$ mosquitto</pre><h3>📡 First MQTT Test with Mosquitto</h3><p>🔹 Open 2 terminals, by default the broker used is localhost.</p><h3>1️⃣ Terminal 1 — Listen to a Topic (Subscriber)</h3><pre>$ mosquitto_sub -t &quot;test/topic&quot;</pre><h3>2️⃣ Terminal 2 — Publish a Message</h3><pre>$ mosquitto_pub -t &quot;test/topic&quot; -m &quot;Hello MQTT!&quot;</pre><p>🎉 Result → Terminal 1 immediately prints:</p><pre>Hello MQTT!</pre><p>That’s your first <strong>bidirectional IoT message workflow</strong>.</p><h3>🎯 Real Use Case Example</h3><p>Imagine:</p><ul><li>ESP32 sends <strong>temperature</strong></li><li>Raspberry Pi listens and stores in <strong>SQLite or InfluxDB</strong></li><li>n8n sends a <strong>Telegram alert</strong> if &gt; 30°C</li><li>Node-RED shows <strong>live graph dashboard</strong></li></ul><p>MQTT Topic Design:</p><pre>esp32/livingroom/temp<br>esp32/livingroom/humidity<br>alerts/high_temperature</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fc5bf998f85b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>