It's pure math.What is the maximum amount of physical memory that can be installed?2 (the amount of values a 1 may have) raised to 16 (the amount of bits available) gives 65536, or 64KB.What is the maximum amount of virtual memory that can be accessed?Here is 2 high to 24 that gives 16MB.The other information is irrelevant to these questions.

a) 9 bits, which is the sum of the 3 largest values = 1 0011 0100b) there are some coincidences in the sum of three entries, for example: 0 0001 0101 + 0 0100 1010 + 0 0101 0101 = = 0 0001 0110 + 0 0100 1001 + 0 0101 0101 = 0 1011 0100 discarding "overflow" and using only 7 bits: 011 0100 In addition, the sum of the UP, Start and C keys will result in the B key if pressed alone.result: with 7 bits or 9 bits the sum of keys is not a good alternative, because there is coincidence in the result of some combinations.

To development very little. These are different types of architectures. Today this distinction is more cloudy, the same processor ends up having both forms.It is not even that the executable cannot change from one model to another, it cannot change from one architecture specific to another since the instruction set is completely another. an ARM and a MIPS are RISC and cannot carry between them.CISC ( https://en.wikipedia.org/wiki/Complex_instruction_set_computer ) that is the most common form of use of Intel is characterized by having more macro instructions that perform things somewhat more abstract in general consuming several cycles of clock. They tend to produce executable a little less, but with less predictable performance. It usually has an extra consumption of internal processing, not the processing of your code, which can consume more energy, generate more heating, and is often more complicated to program in your Assembly. But you can have some facilities too, and have some specific processing gains.RISC ( https://en.wikipedia.org/wiki/Reduced_instruction_set_computer ) whose largest representative today is the ARM has very simple instructions that make the minimum necessary, so they generate larger executables, even if it is already possible to optimize this, and has more predictable processing. By having fewer abstractions it is simpler to program on it. The abstractions are left to another level. This simplicity is given because the instructions are always the same size and the processor does not have to deal with it.One of the very different features is https://en.wikipedia.org/wiki/Load/store_architecture .It only matters for development when programming in Assembly, even so tangentially.

You're confused https://pt.wikipedia.org/wiki/Endere%C3%A7o_(mem%C3%B3ria) with https://en.wikipedia.org/wiki/Data_structure_alignment (which is reasonable, I myself 10 minutes ago was also confused). One thing is you determine which size of each address, i.e. if you have a variable, register, etc that stores an address, how many different bytes this variable can represent. Another is determining what exactly is being represented - an individual byte? a set of X bytes? Etc.AddressThink of computer memory as a long list of bytes:3f 79 bf 34 aa 60 14 b0 6d 68 c4 5c 1a 21 59 e7 ... 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ... And let's say you want to refer to one of these bytes, let's say to the 6th (Index 5, contains the value 0x60). You will need to save this address somewhere. Let's say you use 1 byte variables only to save addresses. Then somewhere in your memory there will be a given occupying 1 byte with the value 0x05:3f 79 bf 34 aa 60 14 b0 6d 68 c4 5c 1a 21 59 e7 ... 8a 9a 05 dd c3 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ... X-2 X-1 X X+1 X+2 ^ That would be an 8-bit architecture. It is easy to realize that in this case the supported memory size would be tiny - only 256 bytes are addressable... But what if instead of using 1 byte to store addresses you used 2 bytes?3f 79 bf 34 aa 60 14 b0 6d 68 c4 5c 1a 21 59 e7 ... 8a 00 05 dd c3 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ... X-1 X X+1 X+2 X+3 ^^^^^^^ That would be a 16-bit architecture. Now you can address up to 65536 different bytes, but each address occupies 2 bytes instead of 1. See in the example above, as that the address of your variable now does not refer to the given all (0x00 0x05) but rather to the first part of it (0x00). The second part (0x05) is not directly referenced, but is implied by the 16-bit architecture that if a given represents an address, then it must occupy 2 bytes, starting with the one being referenced (X).(and opening a parenthesis, note that we could represent this address for both 0x00 0x05 and 0x05 0x00; the use of one or the other is that it characterizes an architecture big endian or little endian)If you are programming in a lower-level language such as C, you can even do "illegal" things, such as trying to access X+1 directly (0x05). The result would be unpredictable, "catastrophic" perhaps, but the blame would be yours for not following the conventions of your architecture (since the "address" in X+1 is 0x05 0xdd, which can point to an invalid memory region).AlignmentNow imagine that instead of memory we are talking about a hard drive, which may have terabytes or even petabytes or beyond:76 4a 37 9a 9b 5b fe 60 b0 f9 3b 14 d1 3e 62 3a 253050123000 253050123001 253050123002 ... In this case it would be very little practical to address each individual byte of the disk - first because that doesn't make much sense, hardly anyone will want to access "the byte at the address X" outside the context of a file, for example; second because, in order to support ever-greater disks, large addresses would be needed, which wastes space. The solution then is to make not all byte [directly] addressable, but to split the file system into blocks - or clusters - with a fixed size for each block, and instead of saying "the file stored in byte X to Y" we say "the file stored in Block X." In this case, the Operating System knows that to reach the file it is necessary to multiply the block index by the size of each block.The memory of the computer, so I presume (as I said, until a short time ago it also confuses me) does not suffer alignment by default. Some applications can align your data for better management. For example, I noticed that in JVM each object always occupies a minimum of 24 bytes, and always grows from 8 in 8 bytes (i.e. it cannot have an object with 27 bytes, for example, or is 24 or is 32). These specific systems may choose to use less bytes to represent each address in exchange for not being able to have all memory bytes directly addressable. It's a tradeoff that may or may not make sense, depending on the case.ConclusionThen answering your question, there is no waste because if your char 1 byte, the 3 bytes in front of you (and behind) remain available to save other data and other variables, and this data is also directly addressable. Whether a region of memory is "occupied" or not depends only on the alignment the system gives to it, if any.Note: This is a simplified explanation, which does not take into account indirections or https://pt.wikipedia.org/wiki/Mem%C3%B3ria_virtual . In practice, the management of physical memory is a little more complicated than "the X address points to X-thine byte in memory". Fortunately, from the programmer's point of view, this normally happens transparently - the SO gives the programmer the illusion that the whole memory is at your disposal, and every thing is in the place you put. All "magic" happens under the cloths, at least when you are programming normal applications and not lower level things - as components of the OS itself.

If you take the manual of a processor, find the number of clock cycles that any instruction takes to perform. You can find processor manuals Intel in http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html .Then, in thesis, if an instruction takes a cycle to perform, and the processor has 2GHz, it would perform 2 billion times that instruction per second, or each instruction would take 0.5ns to perform.Except that's in theory. In practice, access to memory outside the cache takes dozens or hundreds of cycles to search for that memory inside the cache. Some processors can perform instructions in parallel, so the actual cost in cycles of a set of instructions is quite difficult to accurately predict.

These are two completely different concepts. The address is 4 bytes (in 32-bit architecture). The size of the data can vary according to its type. In general 1 is used to represent a character, but this may also vary. A character is something abstract and can be defined with various sizes and shapes of compose.Making an analogy, address is the location where the house is, the data is the house. It always has the same pattern in a city to tell which address is, but the houses have various sizes and formats.

I would like to understand why Linux has several ISOs for each CPU type (amd64, i386, etc..) and why Windows doesn't need it?Because the processor architecture influences the entire Kernel build and the applications that follow the Linux distribution. Any operating system is this way. Each processor has its own set of instructions. Each set of instructions requires that the assembly the operating system is mounted differently. Windows doesn't escape it. When installing, the installer detects the processor architecture before starting and installing the kernel most suitable for the processor in question. And how do you compile this for every type of architecture?In the case of Linux, GCC by default compiles into 32 bits, but adding the flag -m64 will make the compiler perform a compilation in 64 bits. https://gcc.gnu.org/onlinedocs/gcc-3.1/gcc/i386-and-x86-64-Options.html (compilation for both 32 bits and 64 bits, but only at library level). There is also the option to select other architectures. https://gcc.gnu.org/backends.html .

I'd start reading https://pt.stackoverflow.com/q/142289/101 .PC - is the registrar used to determine in which address it should run then. Every instruction executed makes it move to the next instruction. In RISC processors it is easy because all instructions have the same size and the increment is quiet, in CISC processors you need to find the size in an internal table and increase that. It only points to regions of memory that have code and not data. It can be manipulated by a code when there is some branch in your code, whether by one if, whileousimple goo`, i.e. your code can manipulate you.IR - usually of more internal use has the instruction to be executed, is a kind of cache and only usually is present in RISC processors that performs an instruction in various cycles and needs a greater control than is occurring._ - also usually internal and indicates where a data is to be transferred from or to the processor. It is usually necessary for data transport operations. It is usually used when it will access or assign values to a variable, as shown in the question.MBR - also usually be internal and used as a kind of cache to store the data that will be transferred, this is useful because the processor may be carrying out another instruction while this transfer occurs.Only the PC is useful for those who are programming, and even so if you are using Assembly. Variables are design patterns for access to addresses that can be from RAM or a registrar (as opposed to what the other answer says). It is extremely common for an Assembly programmer to use registers as their variables and minimally good compilers to put as much as they can from local variables and parameters in registers.

Tag of the book Santana,Edu - Computer Architecture. Released by the Federal University of Paraíba: In Figure 1.3, the structure of a previous MOSFET transistor is presented. This transistor is the most used to build digital electronic systems such as computers. The name comes from the abbreviation of “Metal-Oxide Semiconductor Field-Effect Transistor”. Let's see what each word of these means, and this will help us to know a little more about the MOSFET and its relevance. The term MOS (“Metal-Oxide Semiconductor”) comes from the materials used to compose a MOSFET, which are mainly metal oxide and semiconductor.Semiconductors are materials that have properties that do not even allow them to classify as a driver, nor as an insulator. In some conditions he acts as an insulating, and in others, as a driver. The most commonly used semiconductor in transistors is silicon (symbol Si in the Periodic Table). In ambient conditions, silicon acts as an adhesive, but if mixed with other materials, it can become a conductor until the desired intensity.Silicon has become so important that it has modified a whole region of California in the United States in the 1950s, making it one of the most promising in the world to this day. This region has sheltered and sheltered most important companies in the business of computer design, as Intel, AMD, Dell, IBM and Apple, and after software that would run on these computers, such as Microsoft, Oracle and Google. That's right. region is called Silicon Valley.In the transistor of Figure 1.3, “Struct of a MOSFET transistor” the light gray represents a silicon crystal that was doped with negative loads. The dark gray represents the part that has been doped with positive loads.In the normal situation (see Figure 1.4, “Opening and closing of the MOSFET type transistor door”) an electrical current applied in the Drain manages to travel the narrow negative channel and follow to the Source. In this condition we say that the transistor is active. However, if a negative voltage is applied in the Door, the positive loads of the p region will be drawn closer to the Door, and this will close the channel through which the electrical current passed. In that case, we say the transistor is inactive.Figure 1.4. Type transistor door opening and closing MOSFET Why does that matter to us? When the transistor is active, it can be seen with value 1, and when inactive, it can be seen with value 0. So we have the least possible memory of being built. When we want it to save value 1, just turn off the voltage of the Door and apply a current in the Drain. As long as we want it to store value 0, we need to apply a current in the Door and close the channel. So a memory of 8 billion bits can be elaborated with 8 billion transistors like these.Now we know the first aspect that makes transistors essential for understanding the computer. They are used for the construction of memories. Memories based on transistors are also called Solid State Memories. But there are others, not as efficient and miniaturized, as optical and magnetic memories. The important thing is that the smaller we can build these transistors, the better. The opening and closing process of the channel is not instantaneous. It takes a very long time, but when added to the times of all billions of transistors, it becomes relevant. The smaller it is, the narrower the channel is, and therefore the faster it turns on and off, in the same way, the smaller the distance between the Drain and the Source, taking also less time for the electrons to leave the Drain towards the source. This will all make the memory faster. Small transistors also allow more data to be stored by area. That's why today huge storage capabilities are available on devices as small as are the examples of flash drives and memory cards.Transistors are also used to perform logical and arithmetic operations. The charge taken from a transistor can serve to feed another and, if combined correctly, can perform basic logical operations, E, OR, NO and arithmetics, addition, subtraction, division and multiplication. With this, transistors can not only be used to store data, but how to perform logical and arithmetic operations on that data. That's fantastic and it's revolutionized all over the world. Not only in Computer Science, but also in all areas of knowledge. What would be of humanity today without the computer? Without the cell phone? Without the satellites?

Open/Close: It means you have to make a design so that when adding new functionality you don't have to touch the existing code.Imagine that you have a billing application and several types of customers, defined in an enum, and to bill you do something like:switch (cliente.getTipoCliente) { case TipoClienteA: facturarClienteA(cliente); break; case TipoClienteB: facturarClienteB(cliente); break; If you add a type of customer, you have to go to all switches and ifs of typeClose and add logic, modifying code that already works.As an alternative, imagine that you define an interface Facturador, and that in the enum of TypeCliente you have a method that, for each instance, provides you an implementation of Facturador suitable for the type of customer. Then the code above stays like:Facturador facturador = cliente.getTipoCliente.getFacturador(); facturador.facturarCliente(cliente); If you add a new customer, you only need to implement the invoicer and add the item to the enum.Other options are plugin systems and others.That said, I have always found that it is the most complicated criterion to implement, and I apply it only for well-defined blocks (remember that SOLID are recommendations, not absolute rules).The principle of substitution is that an instance of a subclass should always function in a coherent manner as a superclass instance would. For example, imagine public class A { public int valorAbsoluto(int val) { return val < 0 ? -val : val; } } public class B extends A { @Override public int valorAbsoluto(int val) { return 0; } } It doesn't make much sense, does it? If you pass an instance of B a x method that accepts AYou can end up having a DivideByCeroError Even though x has made the correct checks.The problem is that the instance of B does not act as an instance of Aeven though it is also an instance of A (as an instance of a subclass of A).Liskov's principle adds that, in addition, history must be taken into account. Imagine that every method of B fulfills the implementation Aexcept that after calling each B method you must call a method reset()or the methods of B They must be called in a certain order. A code that hopes to use A instances will not take into account those restrictions, which will give back in unexpected/erroneous results.

By developing an application:It is advisable to work in layers as it allows you to reuse code, ease for maintenance, program using POO, separation of responsibilities, scalability in your application, you can use a three-layer or n-layer architecture according to the complexity of business. https://msdn.microsoft.com/es-es/library/ms954595.aspx https://blogs.msdn.microsoft.com/cesardelatorre/2010/03/11/nuestro-nuevo-libro-guia-de-arquitectura-n-capas-ddd-net-4-0-y-aplicacion-ejemplo-en-disponibles-para-download-en-msdn-y-codeplex/ About the Framework if you refer to the ORM's you can use among the most known: Entity Framework, NHibernate:With an ORM we can map our data model to our objects and class structure of our application, achieving with this solve the access and persistence of data without much effort and power focus on what we really care about, the domain of business. https://msdn.microsoft.com/en-us/library/ee712907(v=vs.113).aspx

Because Dapper and not Entity Framework https://msdn.microsoft.com/en-us/data/dn468673.aspx with this you could map procedure to entities and also if you want to have an entity let the ORM itself be the one that generates the queries.What if I didn't recommend that you generate a class like that Stored, but you should implement the patron Repository http://ltuttini.blogspot.com.ar/2013/06/entity-frameworkcode-first-crear.html Then you can generate a RepositoryBase with common functionality, but that you can also extend, but the design is done according to the entity that represses your business model.

It's added. ProveedorId because on the board Compra defines a Compound primaryThat's why you visualize the fields CompraId and ProveedorId above the line that separates them from the rest.Eliminates as part of the primary of the board Purchase to ProveedorId and you'll see how this makes it disappear DetalleCompra.

Short answer: Yes, it exists.Response Long: There are a couple of design patterns that can fit into your previous post, actually depending on the abstraction level of it.It seems to me that you particularly refer to the pattern of design Factory Abstracta where your main class delivers an interface to create target families with similar structures (at least in the initial structure). Although it is true that everything is contained in single object, as I mentioned earlier, everything depends on the level of abstraction of the observer because at the end of the day you get different instances of other objects.It also falls within the definition of the pattern Factory regular because it could be said that the subclasses are the ones who decide that it will be created by an alternative builder.As a recommendation, https://sourcemaking.com/design_patterns has excellent documentation on patterns and design antipatrons.Finally, it is difficult to understand what you mean by your question because there are many levels of abstraction in the example and everything is open to personal interpretation. I suggest you unwind that you are looking for exactly if this has not answered the main question.

First of all, what you have ES a framework, but you should set a starting point for the application and load the modules by inheriting the previous functionality, I would start by defining a general class that encompasses them all:class APP { // aquí deberías incluir todas las propiedades como protegidas, // así únicamente una clase que herede de APP podrá obtener su // contenido y podría modificarlo (todas las clases deberían // heredar de APP, por lo que no tendrías inconvenientes de // acceso, pero lo restringes a tu framework) protected CONTENTMANAGER; protected MENUMANAGER; protected FORMMANAGER; protected PROCESSMANAGER; protected MODALSMANAGER; protected DBMANAGER; public function __construct() { // requerir sólo lo necesario en cada caso require_once 'control/config/config.externas.php'; require_once 'control/config/config.genericas.php'; require_once 'control/config/config.modulos.php'; // no instanciar nada aquí } } And then make every part of the system inherit from the base of the same:class Class_MAIN extends APP { public function __construct(){ // Llamar al constructor padre para que genere los require parent::__construct(); $this-&gt;CONTENTMANAGER = new Class_ContentManager(); } public function Main(){ $this-&gt;CONTENTMANAGER-&gt;Gen_Display($USERLoged, $DTACheck); } } If you need to load modules or start classes before you use some part of the system, what you have to do is load the builder of the class that it extends, in this case it would be APP and then load the modules or install the properties:class Class_ContentManager extends APP { public function __construct() { // Llamar al constructor padre para que genere los require parent::__construct(); // Poblar las propiedades requeridas para el funcionamiento de la página $this-&gt;MENUMANAGER = new Class_MenuManager(); $this-&gt;FORMMANAGER = new Class_FormManager(); $this-&gt;PROCESSMANAGER = new Class_ProcessManager(); $this-&gt;MODALSMANAGER = new Class_ModalManager(); $this-&gt;DBMANAGER = new Class_BDManager(); } function GetMenuSide() { require_once "sources/tpl/navside/start.side.php"; $this-&gt;MENUMANAGER-&gt;MenuSideManager(); require_once "sources/tpl/navside/end.side.php"; } } In this way, you prevent it from being requested and instituted twice the same class and you can use it in all the subsequent layers.Edition:If what you want is that certain functionality is available for all classes that inherit from APP, you just have to include that functionality in APP, for example, if you want to have already instanced database functionality, class APP would remain as follows:class APP { // aquí deberías incluir todas las propiedades como protegidas, // así únicamente una clase que herede de APP podrá obtener su // contenido y podría modificarlo (todas las clases deberían // heredar de APP, por lo que no tendrías inconvenientes de // acceso, pero lo restringes a tu framework) protected CONTENTMANAGER; protected MENUMANAGER; protected FORMMANAGER; protected PROCESSMANAGER; protected MODALSMANAGER; protected DBMANAGER; public function __construct() { // requerir sólo lo necesario en cada caso require_once 'control/config/config.externas.php'; require_once 'control/config/config.genericas.php'; require_once 'control/config/config.modulos.php'; // instanciar sólo lo necesario $this-&gt;DBMANAGER = new Class_BDManager(); } } And then eliminate all instances in the builders of $this->DBMANAGER to prevent them from reloading in each layer.Update - Final SolutionSeeing your code in detail and analyzing what it does and your explanations, I think what you need is a code like the following:// los objetos creados, serán globales $Objects = []; // clase que maneja las clases ;) class ClassManager{ // Función de carga de clases, es estática para evitar tener que // instanciar el manejador de clases, agrega la clase al arreglo // de objetos globales y retorna la instancia generada public static function LoadClass($clase, $nueva_instancia = false){ // Obtengo los objetos globales global $Objects; // si no existe el objeto de esta clase o existe pero // se requiere una nueva instancia if(!isset($Objects[$clase]) || (isset($Objects[$clase]) &amp;&amp; $nueva_instancia == true)) { // cargo el archivo require_once "class/$clase.php"; // instancio $instancia = new $clase(); // agrego la instancia al arreglo de objetos globales $Objects[$clase] = $instancia; } else { // sino, obtengo la instancia del arreglo de objetos globales $instancia = $Objects[$clase]; } // y retorno la instancia return $instancia; } } what you will have to do later is, anywhere in your code you need to instance (or get an instance, depending on the case) will be:ClassManager::LoadClass('DBManager')->BDQuery(datos); In case you need to reload the instance, you should put the second LoadClass parameter into true:ClassManager::LoadClass('ErrorManager', true)->ShowError('Lo que sea'); I hope it serves you.

For the answer, need to differentiate between two variables.the bytecode produced by the compiler is independent of the platform and is executed in a variety of virtual machine implementations, as http://www.oracle.com/technetwork/java/javase/tech/index-jsp-136373.html , IBM J9, Dalvik, OpenJDK or others, independent with which SDK It was generated.The Java version used (Java6, Java7, Java8) is spiced as "target version" cannot be higher than the version of the virtual machine.For example: Java code compiled with a 64bit SDK with "target version" Java 7 for example runs in all 32bit or 64bit version 7 virtual machines up.

A possible implementation, in C, of a variable of the language Javascript:enum VarialeType { Undefined = 0, Nil, Bool, String, Number, Array, Object }; struct String { size_t length; size_t alloc; int ref_count; // Contador de referencias, para liberar la memória. char value[]; }; struct Object { int ref_count; ... }; struct Array { int ref_count; ... }; struct Variable { int type; struct Object *scope; // Ámbito de la variable. Similar a un Object. // También podría considerar como su "padre". union { struct String *str; double number; struct Array *array; struct Object *object; }; }; Guys primitive (used and passed by value) are stored in the variable itself.Guys complexes are stored as pointers to the internal data of such types.Without losing the previous sight, it is relatively easy to imagine the process to change dynamically of type:If the guys are the same, it's okay.If the types are not equal, we look at a table of compatible types, to see which operation you have to perform.We create a new variable, with the desired type, for contain The new guy. The Lifetime of such variable is limited to the expression in which it is used, but the process of creating it does not take into account this.The last point implies that each variable must have a scopea container, a ambitwhich limits his time of life.It also implies that the original variable It doesn't change.except for the assignment.Yeah. We assign a new value to the variable, as it depends. If it's a primitive (for value), it is changed and ready.If it is complex, we would make -1 the reference counter, and check if the reference number == 0So we could release the memory.The subject of the reference count... is complicated., and I myself am not sure to understand it at all.. .For languages interpreted, da relatively the use of dynamic or static type; in the end, we will search in a table hash the variable, and create it in the heap; already placed, we do not care to reserve a memory block of 20 or 100 bytes (other memory reserve optimization techniques).In languages compiledThe thing changes. A variable is a alias for a specific memory address; looking for the highest speed, such memory address is fixed during the entire time of implementation of the program ... ergo we can't change the size of that block; therefore, we cannot change the type.Existence languages compiled that bear a great dynamism, though cheating: for variables that can change type, create them always. in the heapand access by a pointer. I recommend taking a look at the source code. libobjc, the support library in time of implementation of Objective-C (comes with the sources of gccin its version 2.xx I don't know, but the version 1.x it's superb to learn about dynamic types compiled.We're here so far... for now. I look forward to comments (as far as possible) on some specific subject ... until they close the question

In my opinion, it depends on the scope of these anicious classes.If they should be visible outside the main class that contains them, they should not be there and should be independent classes.If they are classes that are used exclusively within the main class, for example to facilitate operations, I would leave them inside.

Welcome to SO. The most elegant (although not the simplest) is that you can use a project repository (git?) to which you can push versions stable in your local network. The raspi could be verifying that repo each time (a cronjob) and when there is a new version to do the automotive update process (from everything in the new version). That way you avoid having to be updating each of them.This is a description of the logic to muuuuy great traits. You're gonna find dozens of details that unravel on the road.

Compare a processor with ARM architecture and a processor with x86_64 architecture (or AMD64) is like comparing a passenger plane and a hunt: Certain features will be similar but are totally different concepts.Enlarge in the details would give to write a book, so I will simply list the basic differences:The company ARM license (which does not manufacture) CPU designs based on a RISC architecture. Among these designs we can find some 32-bit and some 64-bit. Companies that make use of these designs: Apple, Mediatek, Samsung, Qualcomm, NVIDIA, AMD, Huawei...AMD designs and manufactures (actually outsources manufacturing, but it is a minor detail here) its own processors, based on Intel x86 architecture but with its own extension to use 64bits. It is considered an architecture of type CISC.ARM processors are characterized by low consumption, while AMD processors focus on process power. This makes the ARMs the absolute dominators in the mobile device market while the AMD64s are the most used (there are exceptions in both cases).Therefore we can say the AMD64 processors speak a language other than the ARMs: a code compiled for one is not executable on the other.Using 64 bits or not does not make them understand each other: it simply indicates that memory addresses use 64 bits (with which they can address 264 bytes (16 exibytes), instead of the former 232 bytes (4 gigibytes). In addition, each "normal" instruction (not floating point and not https://en.wikipedia.org/wiki/SIMD you can now process 64 bits at once, so in principle you can process more data at once (this is not always possible, it will depend on the nature of the data)