<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Computer Architecture on Ciência Programada</title>
    <link>https://cienciaprogramada.com/categories/computer-architecture/</link>
    <description>Recent content in Computer Architecture on Ciência Programada</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <managingEditor>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</managingEditor>
    <webMaster>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</webMaster>
    <copyright>© 2026 Francisco Bustamante</copyright>
    <lastBuildDate>Wed, 27 May 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://cienciaprogramada.com/categories/computer-architecture/index.xml" rel="self" type="application/rss+xml" />
    
    <item>
      <title>Simplifying Logic Functions: Minterms, Maxterms, and the Karnaugh Map</title>
      <link>https://cienciaprogramada.com/2026/05/simplifying-logic-functions/</link>
      <pubDate>Wed, 27 May 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/05/simplifying-logic-functions/</guid>
      <description>How do we go from a truth table to the leanest Boolean expression? We show three paths: the canonical forms with minterms and maxterms, algebraic simplification, and the Karnaugh map, with worked exercises and a check in Python with SymPy.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/05/simplifying-logic-functions/featured_0071.jpg" />
    </item>
    
    <item>
      <title>Boolean Algebra: the mathematical foundation of digital computing</title>
      <link>https://cienciaprogramada.com/2026/05/boolean-algebra/</link>
      <pubDate>Wed, 20 May 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/05/boolean-algebra/</guid>
      <description>Every operation of a processor can be described with three logical operations: AND, OR and NOT. We go from gates and truth tables to theorems, De Morgan&amp;rsquo;s laws and the simplification of expressions, with the half adder as the first circuit and examples in Python.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/05/boolean-algebra/featured_0070.png" />
    </item>
    
    <item>
      <title>Advanced Architectures: RISC, Flynn, and Modern Parallelism</title>
      <link>https://cienciaprogramada.com/2026/05/advanced-architectures/</link>
      <pubDate>Thu, 14 May 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/05/advanced-architectures/</guid>
      <description>With 10% serial code, eight cores make the program only 4.7 times faster, and no number of cores gets past 10 times. We close the series with RISC and CISC, performance metrics, Flynn&amp;rsquo;s taxonomy, SMP, clusters, NUMA, multicore, and Amdahl&amp;rsquo;s Law.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/05/advanced-architectures/featured_0069.jpg" />
    </item>
    
    <item>
      <title>Input and Output: How the Computer Talks to the World</title>
      <link>https://cienciaprogramada.com/2026/05/input-output/</link>
      <pubDate>Tue, 12 May 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/05/input-output/</guid>
      <description>Busy-waiting on a 10 ms disk, a 1 GHz CPU wastes ten million cycles. We compare the three ways of handling input and output (polling, interrupts, and DMA), calculate the overhead of each one, and see why polling came back with NVMe SSDs.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/05/input-output/featured_0068.jpg" />
    </item>
    
    <item>
      <title>Python and Compilers: A Didactic Bridge to the CPython Pipeline</title>
      <link>https://cienciaprogramada.com/2026/05/python-bytecode-compilers/</link>
      <pubDate>Thu, 07 May 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/05/python-bytecode-compilers/</guid>
      <description>Python does not run your code line by line: first, CPython compiles it to bytecode. With the tokenize, ast, compile, and dis modules, we follow a simple expression from tokens to syntax tree to bytecode, right in the interpreter.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/05/python-bytecode-compilers/featured_0067.jpg" />
    </item>
    
    <item>
      <title>Program Execution: From Source Code to Machine Code</title>
      <link>https://cienciaprogramada.com/2026/05/program-execution/</link>
      <pubDate>Tue, 05 May 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/05/program-execution/</guid>
      <description>You write a line of code, and the processor only understands bits. We follow the translation: the two-pass assembler, the compiler phases, linking and loading. Along the way, GCC cuts twelve instructions down to two with -O2, and we see where Python and Java sit between compiling and interpreting.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/05/program-execution/featured_0066.jpg" />
    </item>
    
    <item>
      <title>Instruction Representation: ISA, Formats, and Addressing Modes</title>
      <link>https://cienciaprogramada.com/2026/04/instruction-representation/</link>
      <pubDate>Thu, 30 Apr 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/04/instruction-representation/</guid>
      <description>The same expression costs 5 instructions with three operands, 7 with two, and 11 with an accumulator. We will see the ISA, the contract between hardware and software, instruction formats, the RISC-V R-type, and the seven addressing modes that tell where each operand is.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/04/instruction-representation/featured_0065.jpg" />
    </item>
    
    <item>
      <title>Data Representation: Bits That Mean Something</title>
      <link>https://cienciaprogramada.com/2026/04/data-representation/</link>
      <pubDate>Tue, 28 Apr 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/04/data-representation/</guid>
      <description>Uppercase and lowercase differ by a single bit in the ASCII table, and that was no accident. To the hardware everything is bits, and the value depends on the reading convention: ASCII, Unicode, and UTF-8 for text, two&amp;rsquo;s complement for integers, and IEEE 754 for real numbers.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/04/data-representation/featured_0064.jpg" />
    </item>
    
    <item>
      <title>Pipeline and Buses: Parallelism and Communication in the CPU</title>
      <link>https://cienciaprogramada.com/2026/04/pipeline-and-buses/</link>
      <pubDate>Thu, 23 Apr 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/04/pipeline-and-buses/</guid>
      <description>An assembly line does not wait for one car to be finished before starting the next, and the pipeline does the same with instructions. We will see the stages, the hazards that stall the line, the speedup calculation, the buses that connect CPU, memory, and peripherals, and the control unit.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/04/pipeline-and-buses/featured_0063.jpg" />
    </item>
    
    <item>
      <title>CPU in Action: The Hypothetical Processor and the Fundamentals of Assembly</title>
      <link>https://cienciaprogramada.com/2026/04/cpu-hypothetical-processor/</link>
      <pubDate>Tue, 21 Apr 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/04/cpu-hypothetical-processor/</guid>
      <description>A hypothetical 12-bit processor with 15 instructions serves as a model for following the complete instruction cycle. We execute LDA and ADD register by register, encode instructions in hexadecimal, and write assembly programs with branches and loops.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/04/cpu-hypothetical-processor/featured_0062.jpg" />
    </item>
    
    <item>
      <title>CPU: Components, Instruction Cycle, and What Happens Inside the Processor</title>
      <link>https://cienciaprogramada.com/2026/04/cpu-components-instruction-cycle/</link>
      <pubDate>Thu, 16 Apr 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/04/cpu-components-instruction-cycle/</guid>
      <description>A 2 GHz processor can execute more instructions per second than a 3 GHz one. To understand why, we open up the CPU: ALU, control unit, registers, flags, decoder, and clock, along with the microevents of the fetch cycle in formal notation.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/04/cpu-components-instruction-cycle/featured_0061.jpg" />
    </item>
    
    <item>
      <title>Cache Memory: Mapping, Replacement, and Writing</title>
      <link>https://cienciaprogramada.com/2026/04/cache-memory/</link>
      <pubDate>Tue, 14 Apr 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/04/cache-memory/</guid>
      <description>With a 95% hit rate, the cache makes the processor see a 4.95 ns memory where DRAM takes 80 ns. We will see why it works (locality), the direct, associative, and set-associative mappings, the replacement algorithms, and the write policies.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/04/cache-memory/featured_0060.jpg" />
    </item>
    
    <item>
      <title>Memory Hierarchy: From Register to Disk</title>
      <link>https://cienciaprogramada.com/2026/04/memory-hierarchy/</link>
      <pubDate>Thu, 09 Apr 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/04/memory-hierarchy/</guid>
      <description>If a register access took one second, a main memory access would take four and a half minutes, and a hard disk access, more than a year. We will see the memory hierarchy, cells, addresses and buses, the sizing formulas, and SRAM, DRAM, ROM and ECC.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/04/memory-hierarchy/featured_0059.jpg" />
    </item>
    
    <item>
      <title>Inside the Computer: How Machines Really Work</title>
      <link>https://cienciaprogramada.com/2026/04/inside-the-computer/</link>
      <pubDate>Wed, 08 Apr 2026 00:00:00 +0000</pubDate>
      <author>contato[@]cienciaprogramada.com.br (Francisco Bustamante)</author>
      <guid>https://cienciaprogramada.com/2026/04/inside-the-computer/</guid>
      <description>You press Enter and the result shows up three tenths of a second later. In that interval, the processor fetched hundreds of millions of instructions from memory. This series of 13 articles explains how: memory, cache, CPU, pipeline, data representation, and program execution.</description>
      <media:content xmlns:media="http://search.yahoo.com/mrss/" url="https://cienciaprogramada.com/2026/04/inside-the-computer/featured_0058.jpg" />
    </item>
    
  </channel>
</rss>
