In computer engineering, computer architecture is a set of rules and methods that describe the functionality, organization, and implementation of computer systems.

Some definitions of architecture define it as describing the capabilities and programming model of a computer but not a particular implementation.

In other definitions computer architecture involves instruction set architecture design, microarchitecture design, logic design, and implementation.


An instruction set architecture (ISA) is the interface between the computer’s software and hardware and also can be viewed as the programmer’s view of the machine. Computers do not understand high-level programming languages such as Java, C++, or most programming languages used. A processor only understands instructions encoded in some numerical fashion, usually as binary numbers. Software tools, such as compilers, translate those high level languages into instructions that the processor can understand.

Besides instructions, the ISA defines items in the computer that are available to a program—e.g., data types, registers, addressing modes, and memory. Instructions locate these available items with register indexes (or names) and memory addressing modes.

The ISA of a computer is usually described in a small instruction manual, which describes how the instructions are encoded. Also, it may define short (vaguely) mnemonic names for the instructions. The names can be recognized by a software development tool called an assembler. An assembler is a computer program that translates a human-readable form of the ISA into a computer-readable form. Disassemblers are also widely available, usually in debuggers and software programs to isolate and correct malfunctions in binary computer programs.

ISAs vary in quality and completeness. A good ISA compromises between programmer convenience (how easy the code is to understand), size of the code (how much code is required to do a specific action), cost of the computer to interpret the instructions (more complexity means more hardware needed to decode and execute the instructions), and speed of the computer (with more complex decoding hardware comes longer decode time). Memory organization defines how instructions interact with the memory, and how memory interacts with itself.

During design emulation, emulators can run programs written in a proposed instruction set. Modern emulators can measure size, cost, and speed to determine whether a particular ISA is meeting its goals.

Computer organization:

Computer organization helps optimize performance-based products. For example, software engineers need to know the processing power of processors. They may need to optimize software in order to gain the most performance for the lowest price. This can require quite a detailed analysis of the computer’s organization. For example, in an SD card, the designers might need to arrange the card so that the most data can be processed in the fastest possible way.

Computer organization also helps plan the selection of a processor for a particular project. Multimedia projects may need very rapid data access, while virtual machines may need fast interrupts. Sometimes certain tasks need additional components as well. For example, a computer capable of running a virtual machine needs virtual memory hardware so that the memory of different virtual computers can be kept separated. Computer organization and features also affect power consumption and processor cost.


Once an instruction set and micro-architecture have been designed, a practical machine must be developed. This design process is called the implementation. Implementation is usually not considered architectural design, but rather hardware design engineering. Implementation can be further broken down into several steps:

Logic implementation designs the circuits required at a logic-gate level.

Circuit implementation does transistor-level designs of basic elements (e.g., gates, multiplexers, latches) as well as of some larger blocks (ALUs, caches etc.) that may be implemented at the logic-gate level, or even at the physical level if the design calls for it.

Physical implementation draws physical circuits. The different circuit components are placed in a chip floorplan or on a board and the wires connecting them are created.

Design validation tests the computer as a whole to see if it works in all situations and all timings. Once the design validation process starts, the design at the logic level are tested using logic emulators. However, this is usually too slow to run a realistic test. So, after making corrections based on the first test, prototypes are constructed using Field-Programmable Gate-Arrays (FPGAs). Most hobby projects stop at this stage. The final step is to test prototype integrated circuits, which may require several redesigns.

For CPUs, the entire implementation process is organized differently and is often referred to as CPU design.

Computer Architects:

Computer architects oversee the implementation of architecture strategies and policies within companies. They create computer models and standard solutions that save costs, increase capabilities and align with business needs. Their architectural solutions must deliver stability, availability and sustainability. Computer architects may deal with server storage, data backup, virtual recovery and internal applications. In order to produce efficient systems, they must stay up to date on the latest computer, programming and technology trends.

Computer architects formulate strategies that evolve compute architecture, leverage new features, explore new capabilities and improve user friendliness. They may be expected to manage and maintain enterprise-wide architecture patterns, offerings and policies. They may partner with peers and vendors regarding the integration, alignment and convergence of architectural strategies and standards. Computer architects may create communications and presentations that articulate the logic behind programming and production changes.

The Challenge of Architecting:

Creating a computer’s architecture, framework and infrastructure can be quite challenging. Computer architects must be able to present and drive the alignment and adoption of system evolution to programmers, engineers, designers and leaders. This means that they must be able to gain support and elicit alignment for project funding, strategies and recommendations. Computer architects may perform root cause analysis to understand and eliminate reoccurring incidents that impact the architectural structure and performance.

Senior computer architects may update, maintain and create system architectures that support product lines and business goals. They may review, modify and approve existing architectural designs through careful comparative research. Senior computer architects may communicate architecture strategies in order to convince executive management, technical teams and third-party vendors. Senior computer architects must have significant experience in the design, development and deployment of enterprise solutions. They should fully understand computer infrastructure, middleware and integration.

Computer architecture involves the broad infrastructure of modern PCs. All modern computers, mobile devices and similar technology rely on this architectural knowledge. Anyone who wants to become a computer architect should consider becoming an electrical, software or computer hardware engineer.