Difference between developer and programmer. What is plis: concept, definition, programming rules and basics for beginners What is the difference between a programmer and a user

Being a programmer is fashionable now. Films are made about successful programmers, books are written, and in many countries developers are paid well. But despite the fashion for “techies” and innovation, there are many things known to programmers that are surprising to others. Quora contributors have discussed these sociocultural and cognitive differences. Below are the most interesting comments from the discussion.

So, programmers, unlike ordinary people:

1. They understand that all burglary scenes in films are complete nonsense. Here, for example, you can read where the codes that appear on the screens of “IT specialists” in films actually come from. In general, many movie stereotypes about programmers are nonsense, writes Bill Coleman: “We are not all fat, lazy geniuses. In real life, we know how to communicate normally: our work depends on it. And don’t confuse us with electricians; many don’t even have a soldering iron at home.”

The main “hacking” effect on the uninitiated is the open console. “Most people will think I'm just staring at the screen and killing time when I'm actually working. But as soon as you open the console and start typing, they will be convinced that I am trying to hack the Pentagon or do other magical things,” writes one of the discussion participants.

2. While working, 25% of the time they rack their brains over how to figure out what the user might “break” in the application being created. “It's relatively easy to write rules for what a program should do if everything works as it should. It's much harder to write rules for what a program should do if something goes wrong,” writes Kim Moser. At the same time, many users believe that programs should behave like their smarter and more knowledgeable friends.

3. They know that in fact, even the most important software that users use every day contains a terrifying amount of “crutches” that somehow miraculously come together into a working whole. “It’s like taking apart a Boeing and discovering that the brakes are taped together,” writes one of the discussion participants, Ben Cherry. Programmers know that an appalling amount of medical, financial and personal information is stored with negligible levels of system security.

5. They know: if a person had, for example, six fingers on his hands, the main number system in the world would be decimal, and not 10, as it is now.

6. They can name many more powers of two without a calculator than an ordinary person. The abbreviation “k” in expressions like 100k is understood not as “x1000”, but as “x1024”. But while most ordinary people think that programming is mostly about mathematics, programmers know that logic comes first.

7. They know how complex simple things are on the Internet. After all, simple actions, like searching the Internet, are actually supported by many complex processes at different levels.

8. Believe that most people are too vague when trying to explain what they want.

9. They get angry when ordinary people from among relatives, friends and acquaintances constantly ask to “fix the computer.”

10. The beauty of the code may well be compared to a poem, although for the user it will look as terrible as an error message.

FPGA stands for "Field Programmable Gate Array" and is a huge array of gates that can be programmed and rebuilt anytime, anywhere. Many users still do not understand what an FPGA is. “A huge set of gates” is a simplified description of the model. Some FPGAs have built-in hard blocks: memory controllers, high-speed communication interfaces, and PCIe endpoints. There are many gates inside an FPGA that can be freely connected together. The operating principle is more or less similar to connecting individual logic element microcircuits. FPGAs are produced by the world's leading companies Xilinx, Altera, and Microsemi.

History of FPGA development

The FPGA industry grew out of PROM programmable read-only memory and PLD logic devices. In 1970, Philips invented the field programmable matrix. In the design of such an FPGA, which consisted of two plans, a specific implementation of logic circuits was achieved: programmable wired “AND” or “OR”. This gave her the opportunity to implement the function in the form of Sum of Products.

Altera was founded in 1983, and already in 1984 released the industry's first reprogrammable logic device - the EP300 with a quartz window in the package, which allowed the use of an ultraviolet lamp on the matrix to remove the EPROM tag.

To overcome the challenges of cost and speed, programmable array logic was developed that included only one programmable "AND" input into a fixed "OR" gate. PAL and PLA, along with other variants, are grouped as simple programmable logic devices (SPLDs). Such FPGAs, which are integrated into a single chip with provided interconnects for software interconnection of blocks, have been used to meet increasing technological requirements. They are called comprehensive PLDs and are developed by Altera.

Transistors are another class of electronic devices that are programmable based on gate array masks. They consist of transistor arrays that can be connected using custom wires. They have given way to logic blocks, allowing the user to configure on site rather than in the production lab.

The idea to develop the first commercially viable FPGA belongs to Xilinx co-founders Ross Freeman and Bernard Vonderschmitt. The XC2064 was invented in 1985 and consisted of 64 configurable logic blocks with 3 lookup tables. It gives a modern understanding of what an FPGA is. It was in late 1980 that Steve Casselman's proposed experiment to create a computer with 6,000,000 reprogrammed gates found sponsors in the US Navy's Surface Warfare Division and was then granted a patent in 1992.

By the end of 1990, there was greater competition in the FPGA industry, and Xilinx's market share began to decline. Players such as Actel, Altera, Lattice, QuickLogic, Cypress, Lucent and SiliconBlue have carved out a niche in the global FPGA market along with Xilinx. In 1997, Adrian Thompson succeeded in combining FPGA programming and genetic algorithm technology with FPGAs, ushering in a new era of Evolvable.

Today, FPGAs have become quite affordable, and therefore continue to gain popularity in consumer markets. They consist of a set of logic cells called LUTs surrounded by an interconnect network, providing a flexible system that can implement virtually any digital algorithm.

Programming Principles

FPGA programming for beginners is the process of learning, planning, designing, and implementing a solution on an FPGA. The number and type of layout varies from program to program. Creating a requirements document and creating a design document that explains how the proposed solution will be implemented can be very helpful in solving potential problems.

The time spent creating a high-quality design document will save time in the future on refactoring, debugging, and fixing errors. Implementing a solution using FPGA programming involves creating a project using one of the design introduction methods. These include schematics or HDL code, such as Verilog or VHDL. FPGAs can program the output file to the physical FPGA device using Altera's FPGA programming tools. The introduction of schematic design is no longer used in industry. Synthesis and programming are almost entirely taken care of by vendor tools such as ISE and Vivado and Numato Lab configuration tools.

RTL stands for Register Transfer Level. A designer may also encounter the terms Register Transfer Logic or Register Transfer Language, which all mean the same thing in a hardware design context. RTL is a higher-level abstraction for digital hardware design that falls somewhere between strictly behavioral modeling at one end and purely structural at the gateway level at the other.

Gate modeling means describing the hardware using basic gates, which is quite tedious. RTL can be thought of as analogous to the term "pseudocode" used in the fundamentals of FPGA programming. You can describe hardware design as a series of steps or data flow from one set of registers to the next in each clock cycle.

RTL is also called "data flow" design. Once the RTL design is ready, it is easier to turn it into actual HDL code using languages ​​such as Verilog, VHDL, SystemVerilog, or any other hardware description language.

FPGAs are much more than just a bunch of gates. Although it is possible to build logical circuits of any complexity by organizing and connecting logical elements. It's a way to express logic in a simple format that can eventually be turned into an array of elements. Two popular methods for doing this are introducing schema and hardware description language HDL. Before it became widely used, engineers designed everything using circuit diagrams. They were very simple for small projects, but painfully unmanageable for large ones. One can only imagine how Intel engineers draw diagrams for the Pentium, which has millions of gateways! This is unacceptably difficult.

Verilog is an HDL hardware description language that can be used for digital circuits in text form. Learning Verilog is not that difficult if the user has programming experience. VHDL is another popular HDL widely used in the industry. Verilog and VHDL have more or less equal acceptance in the market, but users usually choose Verilog because it is easy to learn and has syntactic similarity with C language.

FPGAs can be considered the building blocks that enable the desired hardware configuration. It is a special form of PLD with higher density and enhanced functionality in a shorter period of time using CAD. FPGAs are available in different variants based on the programming technology used.

They can be programmed using:

1. Antifuse Technology.
2. Programming based on Flash technology as a device from Actel.
3. The FPGA can be reprogrammed several thousand times, taking a few minutes in the reprogramming field itself, and has non-volatile memory.

FPGA based on SRAM technology, which offers unlimited reprogramming and very fast reconfiguration or partial reconfiguration during operation with a small amount of additional circuitry. Most companies like Altera, Actel, Atmel and Xilinx produce these devices.

Configurable Logic Blocks

Regardless of different manufacturers and slightly different architectures and feature sets, most FPGAs share a common approach. The basic component blocks of any FPGA are a flexible programmable "logic block" (CLB) surrounded by programmable "input/output blocks" with a hierarchy of routing channels connecting the various blocks on the board.

In addition, they may consist of DLLs for distributing and managing clocks and dedicated block RAM memory with the main building block being a logical cell. The latter consists of an input function generator, transfer logic and storage elements. Generators are implemented as lookup tables and depend on the introduction. For example, the Xilinx Spartan II has 4 input LUTs, each providing 16X1 bit synchronous RAM, using multiplexers as shift registers to capture data in burst mode. Storage elements are sensitive to the edges of the triggers or the level of the slides.

1. Arithmetic logic includes an XOR gate to operate a full adder and allocate logical carry lines.
2. I/O block and routing matrix. This block has inputs and outputs supporting a wide range of signaling standards and interfaces.

The basic I/O block is shown below.

Buffers in the input and output paths route signals to the internal logic and output pads directly or through a flip-flop. They are configurable to a variety of supported signaling standards, which can be user defined and externally installed.

Routing Matrix

On any assembly line, the slow segment determines overall productivity. Routing algorithms are used to design the most efficient paths to achieve optimal performance. Routing occurs at different levels, such as local, general purpose routing between different CLBs, I/O routing between blocks and CLBs, dedicated routing for specific signal classes to maximize performance, and Global Routing to distribute clock and other signals with very large fan-out. . FPGA families also have large RAM block structures to complement distributed RAM LUTs, the size of which varies among different FPGA devices.

FPGA design involves essentially the same approach as any VLSI system, with the main steps being design, behavior simulation, synthesis, post-synthesis simulation, translation, mapping and routing, and subsequent analysis such as timing simulation and static timing analysis. On the computer, the design appears ordered and tiled, but in reality there is poor placement and routing, resulting in poor performance.

To improve the performance of an FPGA, you can always use more transistors. The service area is high. Installing more transistors means that large-scale designs are possible. Leakage is a serious problem for FPGAs and at the same time interesting. The use of asynchronous FPGA architecture shows best results when combined with pipelining technology, which reduces global inputs and improves throughput.

Gate quality and problems

System security has always been a major concern since code must be exposed every time it is loaded into the FPGA. This flexibility makes FPGAs susceptible to malicious modifications during manufacturing, so bitstream encryption came to its rescue just in time.

Often, inexperienced designers and users are faced with the dilemma of how powerful an FPGA is suitable for their designs. Manufacturers often provide metrics such as “number of gates.” For example, Xilinx FPGA programming uses 3 metrics to measure FPGA capacity, maximum gates, maximum memory bits, and typical gate range. As long as they are consistent, migration between models is somewhat easier, but it rarely offers an accurate comparison across vendors due to diversity in architectures and performance differences.

The best indicator is to compare the type and amount of logical resources provided. In addition to this, the designer must fully understand what exactly is needed from the device, since manufacturers will boast of features that will make the least difference to the job. For example, Altera's Stratix II EP2S180 has about 1,86,576 4-input LUTs, while the Xilinx Virtex-4 XC4VLX200 contains 1,78,176 respectively. However, if the design only needs 177k LUTs, this will be sufficient.

If RAM is a desirable metric for a designer, then neither the 6Mbit Xilinx XC4VLX200 nor the 9Mbit Altera EP2S180 would be preferable to the less advertised, older 9.9Mbit XC4VFX140 model.

Programming languages ​​and software

Programming Altera FPGAs for beginners starts with choosing a language. The C, C++ or System C option allows you to take advantage of the capabilities of the largest devices and, at the same time, achieve realistic development graphics. The ability to use C for FPGA design is provided by HLS (High Level Synthesis), which has been on the verge of a breakthrough for many years with a tool like Handle-C. This has recently become a reality with major vendors Altera and Xilinx offering HLS in their Spectra-Q and Vivado HLx instrument suites, respectively.

A number of other C-based beginner Altera FPGA programming implementations are available, such as OpenCL, which is intended for software developers wanting performance gains with FPGAs without a deep understanding of FPGA design.

As with HDL, HLS has limitations when using FPGA programming approaches in C; as with traditional HDL, developers have to work with a subset of the language. For example, it is difficult to synthesize and implement system calls because you need to make sure that everything is bounded and of a fixed size. The nice thing about HLS is that you can develop your own floating point algorithms and there is an HLS tool for converting floating point to fixed point.

Programming FPGAs with Xilinx software is not difficult at all. You can get it by purchasing Xilinx products, free of charge or at a model-specific price. You can access the video on the profile website, which clearly shows the usage procedure. Of all the companies to choose from when looking for programmable gate arrays, Xilinx is by far the best of the bunch. They are the creators of this product and have been making improvements to it over the years. Branded software has become more powerful than ever before.

Design stages

FPGA programming training can be done online as the platform is well represented on the Internet. When setting up an FPGA, the first step is to design the circuit, which requires knowledge of digital electronics. Unlike programming, it is much more difficult to start slicing code if the program's architecture is not clear. As soon as it becomes clear what needs to be implemented, we begin to describe the circuit using one of the languages: Verilog or VHDL.

A fact that shows a paradigm shift is that they are not called FPGA programming languages, but are description languages. Due to the complexity of testing digital circuits, test banks that simulate the behavior of the equipment are usually used at this stage. This type of tool allows you to see the state of the signal at any moment and check if there are transitions with the desired results.

The third stage is known as circuit synthesis and is one of the key ones. It selects the elements to be used and their relationships according to the description files. This step requires tools that facilitate and automate tasks in most situations.

Hardware and setup

Intel Quartus Prime Software Suite Lite Edition is FPGA design software. It is ideal for beginners as it is free to download and no license file is required. You can download the software from the manufacturer's website. The files are large (several gigabytes) and can take a long time to download and install. To minimize time and required disk space, it is recommended to download only those items that are necessary for user tasks. When prompted for files to download, uncheck “Select All” and select only Quartus Prime and Cyclone V support devices.

Algorithm for creating a project:

1. Open the New Project Wizard.
2. Select Next > Directory > Name > Top Level Object.
3. Select a directory to place the project, for example, “Blink” and place it in the intelFPGA_lite folder, but you can place it anywhere and click “Next”.
4. When prompted to create a directory, select Yes.
5. Select “Empty Project” and click “Next”.
6. Add files and “Next”.
7. Set up families, devices and boards by selecting the following: family - Cyclone V, device - Cyclone V SE, base, device name: 5CSEBA6U2317.
8. To select a specific device, you need to press the up/down arrows to see a list of supported devices until 5CSEBA6U2317 appears.
9. The user may need to expand the "Name" field to see the full name of the device, click "Next".
10. When setting up the EDA tool, they use standard tools, so there will be no changes, click “Next” and “Finish”. The summary screen appears.
11. Create an HDL file with Verilog embedding as HDL.
12. Go to the File tab (main window) and select New.
13. Select Verilog HDL File and click OK.
14. Select "File" > "Save As".
15. Select a file name. This is the top-level file name and must be the same as the project name.
16. Click “Save”.
17. Create a Verilog module.
18. Copy and paste the Verilog code below into the blink.v window and then save the code file.
19. Right-click "Analysis and Synthesis" and then click "Start" to perform syntax checking and synthesis of Verilog code.

If the process completes successfully, a green check mark appears next to Analysis and Synthesis. If there is an error, check the syntax and make sure it exactly matches the code block above.

All experienced programmers know that complex programs, even subroutines, do not work correctly the first time. Human abstraction abilities, based on experience, allow him to find solutions without worrying about the smallest details. But the hard truth is that the physical system in which programs are embedded requires that every little detail be taken into account before everything works.

With the improvement of FPGA development software tools mainly from traditional vendors as well as independent tool vendors: Synplicity, FPGA is becoming more popular day by day. Now, FPGAs have begun to include specialized hardware for customer-required functions, reducing costs for manufacturers. Thus, in the future there may be competition between rigid and low-cost systems with flexible cores. Costs are expected to fall even further in the near future as FPGAs become more popular.

Manufacturers have begun to experiment with the concept of embedding FPGAs into integrated circuits to create a hybrid device. The focus remains on interconnect routing, and CLB architectures are seeing less change. As FPGAs continue to power processors, the new generation will require not only digital design hardware knowledge, but also developer experience in the process of one-time FPGA programming. Overall, FPGA is expected to take the market share in ASIC devices and become the dominant technology covering many applications from various domains.

In the context of working with software products, people are divided into users and programmers (maintainers, implementers, etc.). This article addresses the relationship between these two categories.

Most users are very conservative when it comes to automation. It can be very difficult to convince a person of the advisability of changing the system (connection problems arise, for some time you will have to work simultaneously in two systems, the new system may require a different approach to performing the usual work.) But having gradually adapted to the new system, the user will appreciate all its advantages. Compared to the old one, this is the best reward for a programmer.

One small note.

Most users have no idea of ​​the differences between a system administrator, a programmer, or a Unixoid.

For them, a programmer means he can fix a computer, find everything on the Internet, solder a broken wire, restore information deleted from the hard drive.

• Of course, this is not entirely true, but this is the image of a programmer in the mind of an ordinary user.
• Some points that deserve special attention when installing and further operating the system:
• Any user prefers to work with the same specialist, who is aware of all the problems that periodically arise during operation. Therefore, if possible, avoid situations where another specialist is working with your client.
• Don't be too intrusive with your advice, especially if you are not asked for it. And don’t insist on your point of view - it’s enough just to express your opinion. Let the final decision rest with the user.
• Strive to improve your knowledge not only in programming, but also in your client’s professional field - this will allow you to communicate in the same language. Users often ask questions related to the specifics of their professional activities.

A few years ago, when asked “what do you do?” you could wiggle your eyebrows meaningfully and say, “computer geek.” That was enough. Explaining subtle matters to unprepared people who, at best, could boast of a line on their resume “Confident PC user” was unnecessary, as it would only give rise to even more questions. But times are changing, literacy is increasing, and now, when “confident PC user” has become an atavism, it has been followed by the once universal word “computer specialist.”

The professions of a programmer and a developer have a lot in common, and in everyday life these words are often used as synonyms, but there is a difference, although not always noticeable. Otherwise, why did such concepts as software developer, computer scientist and programmer appear at all?

Programming

Today there are no clearly defined rules about who is called a programmer and who is called a developer. Therefore, there is no other way out but to turn to the origins.

Computers, the Internet, mobile communications, as well as a host of other wonderful things that are now in the public domain, if not invented by the military, sooner or later fell under their sensitive wing and supervision. If something can fly, shoot, explode, or protect against similar enemy actions, you have a team of scientists. Sign and receive. In a high-tech age, a soldier without a scientist would have a hard time - after all, even such little things as combat boots and body armor have absorbed a lot of technological know-how. What can we say about programming laser guns and intercontinental missiles!

If it were not for the need that stimulated the state to find money for financing, it is unknown how many decades later we would have had computers and the Internet at our disposal. So those who have not yet had time can mentally thank the aggressor states that, in the fire of wars, gave birth and continue to give birth to new technologies.

And even having moved into the future a couple of decades, it is still difficult to imagine some Bill Gates who would assemble in his garage a computer 17 meters long and more than 2.5 meters high, which would consist of 765 thousand parts, synchronized using 15 -meter shaft and was driven by an electric motor with a power of 5 horsepower - like the Mark-1, developed by several Harvard mathematicians under a contract with IBM in 1941.

This was too labor-intensive and brain-intensive, so historically it happened that whoever built the computer “danced” it. There were few computers - by the end of the war, only 10 of the same “Colossi” were working. Only a few years later the first commercial models began to appear - for example, the IBM 701 (19 units were sold in the first year), or the IBM 650 (450 units were already sold in the first year). The main buyers were scientific laboratories, airlines, and government institutions.

And even though since 1965, Americans have begun producing thousands of PDP-8, which costs “only” 18 thousand dollars, it has an imperfect memory architecture, which is why a considerable number of resource-demanding projects on it failed. So programming in those days was not easy (hello hardware) and not at all as convenient and accessible as it is now. There were only a few people who knew how to program. There are even fewer people who could earn something from this. And all this time, the programmer quite deservedly retains the reputation of a “nerd”, a wearer of the same sweater and a regular at libraries. An out-of-this-world prodigy who works in a very narrow field, inaccessible to the masses.

Historically, people with brains who knew how to talk to machines on a first-name basis worked exclusively for the military-industrial complex or in science. From here true programmer in the historical sense of the word, this is a person who writes programs for the defense/weapons complex, for computing power in some design bureaus or scientific institutes, programs robots, rockets for space flight, and so on. Exclusively matters of national importance. Maximum innovation. Monetary interest is either absent or takes second place. The public doesn't care how many billions of dollars they gave to inventors for computers and the Internet, just as they don't care how much money was spent on the Apollo program. But now everyone has a computer in their pocket, and there is a flag and boot prints on the moon. Nobody remembers the rich, but everyone remembers the innovators, because the former consume, while the latter give.

Development

Commercial programming in its pure form did not exist and still does not exist - the word “programming” is clearly out of place here. Here development- another thing. The fact that Microsoft, IBM, HP, Apple and other computer pioneers were capturing markets and making huge money did not change the fact that each new product was a step forward. They solved new, non-trivial problems.

Was Torvalds a programmer? Of course. After all, he wrote the kernel for Linux. In this case, it does not matter at all whether he used the best practices and development methodologies in the process of his work (for example, whether he named the variables correctly, whether he used memory optimally, and so on). The main thing is that it works. And the winners are not judged. Just as Brendan Eich, the creator of JavaScript, is not judged, although objectively there is something for it.

Is a genius and part-time boss of zeros and ones, even smarter than Torvalds and Eich, a programmer if all he does is solve standard problems? For example, he writes online stores. Leading question: is a person who served in the special forces, but now works as a security guard in a store, a special forces soldier or a security guard? Many guards, in order to look better in their own eyes, meaningfully rubbing their army tattoos, call themselves special forces. Rarely does anyone put the word “former” next to their profession. But only a few admit that either they have lost their qualifications and therefore work in security, or they are too cool for the position they occupy, thereby firing a cannon at sparrows.

Some of today's programmers are exactly like this special forces soldier, who is clearly out of place and is exclusively engaged in making money, wasting his talent down the drain. There is another, much larger category of people (99%) who call themselves programmers, but in fact are developers (this category also includes redneck coders). They write and change their own or someone else’s code, communicate with the customer, clients, constantly fix bugs - because the developer can afford to allow them; they work not for an idea, but for money: today for one guy, tomorrow for another. Who will give more?

As one academician said, “A dissertation on philosophy must end with a revolution, otherwise it is not a dissertation”; or, in our opinion, a programmer’s work should end with a technological breakthrough. Otherwise, this is not a programmer's work.

And don’t let the employment records a la “first category software engineer” be misleading. HR’s themselves don’t know what they are doing, using the stamps of a country that disappeared 25 years ago. All you have to do is ask a leading question: “What are you working on now?” Because you can do as complex development as you like with a cumbersome and difficult-to-understand architecture, stuffed with a lot of dependencies and brain-crushing elements, which requires extraordinary mental abilities. But if this is an online store, another fake “service,” a spam robot, or, God forbid, a browser game, and the person doesn’t do programming in his free time, then it smells like development. As in the phrase “development of oil fields”.

Therefore, to the question “What do you do?” A more accurate answer could be “I’m a programmer at heart, but I work as a developer,” “I’m a developer, but someday I’ll become a programmer,” or “I’m a developer, I chop cabbage.” When a situation requires an inaccurate and quick answer, the “programmer” can be understood, after all developer in the context of software, the word is relatively new. But calling yourself a programmer while drinking juice on the outskirts of outsourcing is deceiving yourself.

We often encounter that people do not understand the difference between a system administrator and a programmer and all IT workers are called programmers. Some are offended, while others have already gotten used to it. But I want to try to clarify this difference so that it is clear to most who read this article :)
If an organization has an IT department (engineering), or, more simply, a computer department, then it has the following division:

- the main task is to control the operation of servers and server software, the administration of telephone exchanges, security policy - in general, these are the brains of the entire computer structure of the organization.

Technical support specialists (or engineers)- these are the guys who deal with ordinary users’ computers, set them up, help users solve current problems, catch viruses on users’ computers, etc. and so on. In essence, a Specialist is a future system administrator, because a system administrator can also perform the work of a specialist. A specialist can perform the work of a system administrator if management allows him - management has more confidence in a system administrator :)

Programmers- these are the guys who constantly write various texts in a language that is incomprehensible to the average user. These texts are then turned into useful programs, utilities, or simply modules (additional options) for useful programs.