To apply for a job as a software technician, a person must have an average professional education, it is very good if he also has work experience in this specialty.
What are the job responsibilities of a software engineer?
Of course, what the job of a software technician will consist of largely depends on what area he will work in and what type of activity the company is engaged in. But there are, of course, general requirements and knowledge that will be useful to him in any workplace. First of all, he needs to have a perfect knowledge of computers and the devices used in conjunction with them, as well as devices for collecting, processing and transmitting information, the rules for their maintenance and operation. You will need knowledge of methods and technologies for automated information processing, basic programming languages, specialized software products, used in the work of this enterprise.The job responsibilities of a software technician usually include ensuring smooth operation of computing systems and equipment installed at user workplaces. He will need to perform preparatory operations related to the operation of local computer networks, monitor how workstations operate, and provide technical assistance.
He may be required to develop simple utilities and work programs to optimize the production process; he must debug and test them. In some cases, he may be entrusted with drawing up simple diagrams of technological processes for processing various information flows in an enterprise or individual algorithms for solving those problems that the IT department faces. At many enterprises, software engineers are involved in maintaining databases, filling them, storing them, and processing them. A software engineer at any enterprise must be able to work with large amounts of data, know the rules for archiving and storing them, he must have an idea of
You should start your path to a career as a programmer by answering the question, do you need programming at all? This question does not apply to those who are studying or have studied in a specialty close to programming. If you were better at math at school than the humanities, if you like to spend a lot of time on the computer, if you want to learn something new, then programming is for you.
Where to begin
There are several options for the development of events, as a result of which a person becomes a programmer. The first is parents-programmers who taught their children everything. These children don't even need to go to university. The second option is the fashionable profession of a programmer. After school, we had to choose where to go to study, and we chose the fashionable field of IT, which we seemed to like. And the last option is a hobby that has grown into work.
If none of the above happened to you, then you have a choice of four options:
- Self-education. This option can be used either independently or in combination with other methods. The Internet is full of applications that help you learn various programming languages and technologies. But this is the most difficult path for beginners.
- University. If you finish school and want to be a programmer, then go to university. If not for knowledge, then for the crust. It can serve as a bonus when applying for a job. Although you will also gain some knowledge. But don't forget to educate yourself. Choosing a university should be approached very responsibly. Carefully study the training programs and choose the best technical universities.
- Mentor. It will be very good if you find a person who agrees to help you and point you in the right direction. He will suggest suitable books and resources, check your code, and give useful advice. By the way, we have already written about where you can find a mentor. You can look for a mentor among familiar programmers, at IT parties and conferences, on online forums, and so on.
- Specialized practical courses. Try looking for courses in your city that will teach you some programming language or technology. I was pleasantly surprised by the number of such courses in Kyiv, including free ones and with subsequent employment.
Which language, technology and direction to choose
When you become a programmer, after a year or two you will be free to choose any language you like. But when choosing a first programming language, a beginner should consider the following criteria:
- Availability of vacancies on the market. The ultimate goal of this path is to find a job as a programmer. And this will be difficult to do if no one is looking for developers in your programming language on the job market. Check job sites, see who is most sought after, write down a dozen languages. And move on to the next criterion.
- Low entry level. If you have to spend a long time learning a language, it may discourage you from programming at all. Read about the languages you selected above. Review the literature you will need to read to learn these languages. And choose those that are described as easy, or that seemed easy to you. Such languages may be PHP, Ruby, Python.
- The thrill of the process. If you don't enjoy writing code in your chosen language, you won't enjoy the process, your work, or your life. Do you need it? Make the right choices.
You will also have to decide on the direction of programming. Mobile, desktop, games, web, low-level programming and so on. The most popular and relatively easy industries are development for web, mobile and desktop clients. One language may be suitable for each direction and not another at all. That is, when choosing a programming language, it is also worth starting from this factor.
Either way, learn web technologies. This is HTML markup language, CSS styles and , which will make your page dynamic. The next step is to learn a server-side language (Python, PHP, Ruby and others) and web frameworks suitable for it. Study the databases: almost every programmer vacancy mentions this.
How to get initial experience
Without experience you won't get a job. Without work you won't get experience. Vicious circle real life. But it’s okay, we’ll get out of it.
First, don't wait until you've read every book on your chosen programming language. Start writing your first lines of code after the second chapter of the book. Complete all the tasks from the books, retype the examples, understand them. Complicate the examples and tasks from books with your own ideas. Create your own tasks for the material you have covered. Solve these problems.
Secondly, you need to find your first projects. This is probably the most difficult option, but it works. You will have to look for orders yourself, fulfill them, and bother with payment. For a beginner, this is extremely difficult, but then all other options will seem like a piece of cake. Completed projects can be recorded as experience and shown to your future employer. Real projects are a big plus on your resume.
If you know English language, it is better to register on English-language exchanges. The market is bigger there. If you don't know English, learn it. In the meantime, Russian-language freelance exchanges are available to you. Look for small projects that are at or just above your skill level. Apply for a couple dozen of these jobs. And get ready to receive a sea of refusals. But if one or two applications work out, you'll have a chance to gain real experience.
Another good option for getting real experience is open source. Such projects always need new people, even beginners. You can search for bugs in the project or look in the bug tracker and suggest methods for solving them. You can easily find such projects on GitHub or . Feel free to ask questions there.
The fourth option for gaining experience is helping fellow programmers. Ask them to hand over small, simple tasks to you. If something doesn't work out, you will always have someone to turn to. And at the same time you will participate in a real project.
The last way is your own projects, various hackathons or working in a coworking space. It’s difficult to start your own projects on your own; it’s better to look for acquaintances or friends.
Why choose Python
Let's talk a little more about choosing your first programming language. The first language should be simple and popular in the market. Such a language is Python. I highly recommend choosing it as your first programming language.
The Python program code is readable. You don't even need to be a programmer to get a basic understanding of what's going on in a program. Due to Python's uncomplicated syntax, it will take you less time to write a program than, for example, in Java. A huge database of libraries that will save you a lot of effort, nerves and time. Python is a high-level language. This means you don’t have to think too much about memory cells and what to put there. Python is a general purpose language. And it's so simple that even children can learn it.
In fairness, it is worth mentioning other programming languages. Java could be a good choice for a beginner. This language is more popular than Python, but also a little more complex. But the development tools are much better developed. One has only to compare Eclipse and IDLE. After Java, it will be easier for you to move on to working with low-level programming languages.
PHP- another very popular language. And I think it's even simpler than Python. It is very easy to find a mentor or a solution to a problem on the forum. This is because there are a huge number of PHP programmers of different levels in the world. There is no normal import in PHP; there are many options for solving the same problem. And this complicates learning. And PHP is designed exclusively for the web.
Languages C And C# very difficult for a beginner. Ruby- a good choice as a second language, but not a first. JavaScript- a very simple language, but it won’t teach you anything good. But the task of the first programming language is still to teach you something correct, to set some kind of logic.
Is English important?
Important! Do not know? Teach. Do you know? Improve. Learn to read, write, listen and speak English. Focus on technical literature. Listen to English-language podcasts. Read English-language programming textbooks.
What you need to know besides the programming language
Of course, besides the programming language and English, you need to know something else. But what depends on the direction you choose. A web programmer must know HTML, CSS, JavaScript. A desktop programmer teaches operating system APIs and various frameworks. Developer mobile applications teaches Android, iOS or Windows Phone frameworks.
Everyone needs to learn algorithms. Try taking a course on Coursera or finding a book on algorithms that suits you. In addition, you need to know one of the databases, programming patterns, and data structures. It's also worth checking out code repositories. At least with one. Knowledge of version control systems is required. Choose Git, it's the most popular. You need to know the tools you are working with, operating system and development environment. And the main skill of a programmer is to be able to Google. You won't live without this.
Last steps
You need to prepare a resume. Not just a resume, but a . You shouldn’t write there, but you also don’t need to remain silent about your skills. Once you are invited to an interview, you must prepare for it. Go through the material that is listed on your resume. You must be confident in your knowledge. Look through the projects you've worked on, think about the technologies you've used. And forward - to a bright future with a new profession as a programmer.
A programmer is one of the most important professions. In most modern fields of activity, computers are used, and a specialist of the corresponding profile is the main one who is responsible for their functions that are practically significant for humans, and in many ways for their performance. What skills should a programmer have to successfully solve his problems? What basic knowledge does a person need to become such a specialist?
- features of the tasks solved by a person in a given specialization, as well as the necessary skills and knowledge related to them;
- the specifics of individual software development languages as the main components of a programmer’s toolkit.
Let us consider the essence of the noted aspects in more detail.
What should a programmer know to solve his problems?
A person working as a programmer can deal with a large number of problems. Among them:
- writing computer programs;
- development of software concepts;
- adaptation of programs to different categories of users (in terms of interface and functions);
- testing and debugging of software.
Let's study the essence of these areas of activity of programmers, as well as what skills they must have to successfully perform the relevant functions.
Language competence
Writing programs is the main competence of a specialist in the profile in question. “Software” is created using special languages, and a person has to master the appropriate level of proficiency in them. This is therefore a key requirement for a programmer's knowledge.
Regarding the first task, software can be developed for the internal needs of the company (for example, for the purpose of organizing work with databases and equipment, managing financial flows) or for an external consumer (as part of a corporate order or by introducing the product to the retail market under a commercial brand).
What programming languages should a programmer know? This largely depends on what kind of software he creates. As part of internal corporate tasks, a programmer most often works with databases, servers, debugging, testing, and writing equipment control algorithms. These competencies will most likely require knowledge of universal, multifunctional languages: C, C++, Java, Ruby. When it comes to working with databases, you can't do without knowing SQL. A specialist will need knowledge of Python - one of the easiest to learn, but very necessary and in demand languages.
When it comes to releasing software to order on the external market, the requirements for a programmer's skills are usually broader - since the commercial success of the employing company depends on the functionality and quality of the solutions produced. In addition to the above-mentioned universal languages, a person will need to be proficient in more “narrow-profile” ones - such as, for example, C#, Javascript, PHP, Objective-C.
A little later we will study the features of each of the noted languages in more detail.
Participation in the concept
The programmer's competence may also include solving conceptual problems related to the creation of “software”. A specialist in the profile in question is often involved in discussing a software development project and assessing the prospects for its implementation in practice. For example, a programmer is able to tell colleagues that the proposed product is not entirely optimal for a specific production process and its design requires improvement in such and such an aspect.
While solving problems related to the software concept, the programmer's functions also involve high level his linguistic knowledge. In particular, a specialist must be able to correctly select the optimal language from the point of view of compatibility with the project. For example, Objective-C, which we noted above, is the main one when developing mobile applications for iOS, but as for solutions for Android, one of the most optimal tools for creating them is Java.
The fact that there will always be a language that is better suited for a particular platform than others is one of the main tenets of the profession, and this is what a novice programmer should know before starting a career. Therefore, a good specialist in this profile is definitely a “polyglot” in terms of proficiency in computer languages, and he always has the opportunity to choose the optimal “dialect” for writing software.
When solving problems in the “conceptual” area of activity, the programmer must also have sufficient knowledge of the hardware market: the software that he will create will most likely require adaptation to one or another type of computer or gadget. The specialist will have to ensure higher quality performance of the functions of the “software” he creates in relation to a specific type of equipment than in competitive solutions.
All components are important
Any type of software consists of two basic components: code and interface. The first element is mathematical and logical algorithms written in a special programming language that ensure the functionality of the product. The second is how the software's capabilities will be used by the user, how he will control the functions. A program can be as perfect as it wants from a code point of view, but an inconvenient interface will make its effective practical use difficult to implement.
It is extremely important that the program controls correspond to the wishes of the target user group. It is difficult to develop a product whose capabilities would be comfortable for everyone to use. There will definitely be a significant percentage of people who are dissatisfied with the interface. The most important thing is that the programmer adapts the solution for “his consumer”. It is important that, first of all, he is satisfied.
Take tests
A computer program may offer a wide range of functionality and a user-friendly interface, but if its operation is accompanied by constant failures and errors, then the corresponding advantages will not have any meaning. Therefore, a software developer must have the skills that will allow debugging and the necessary testing of solutions.
There are a large number of types of software for checking the correctness of programs. Popular ones include Device Anywhere, Jira, Android Debug Bridge, iPhone Configuration Utility. The programmer must be able to use them, not counting, of course, knowledge of the languages used to create software for the platforms on which testing is carried out.
Note that in modern companies programmers, as a rule, work in teams. Thus, the listed competencies are most often distributed among individual specialists. For example, identifying failures and problems in software can be carried out by a person in the position of tester. Concept development and interface improvement are also often carried out by individual specialists. But it often happens that all the noted tasks are solved by the same person. This scenario is most common in small companies or startups.
Some IT experts prefer to rank these specializations by skill level. Thus, testers are sometimes, in principle, not considered as programmers due to the fact that they do not often work with “code”. However, the ability to properly check software for errors is, one way or another, an important competency of the developer. Even if he is unable to give the program to someone else for testing, he will have to do the necessary work himself.
The same can be said about the program interface. A specialist with design skills will most likely do a better job of optimizing software management functions than a “general-purpose” programmer. But if a person works in a startup and does not have the opportunity to request the help of a specialist expert, then he will have to do everything himself.
What programming languages should a programmer know?
We noted above that the key competency of a programmer is knowledge of specialized languages that are used to create software, and we listed those that are actively used in the modern IT market. To which areas of business and IT development are certain languages best adapted? How can a programmer decide which one to study?
So, among the most popular languages today: C, C++, C#, Java, Javascript, Ruby, PHP, Python, Objective-C, SQL. What is the reason that a modern programmer should know them?
Regarding the C language, it should be noted that it is one of the most versatile and powerful in terms of capabilities. You can create almost any program on it. This language is very difficult to learn, but this makes knowing it especially honorable. The same can be said about C++ and add that it is even more universal and in demand.
In turn, the C# language is not very close to C, but it takes a lot from C++, as well as Java. As for its application, it is indispensable for programmers working with enterprise types of Windows software.
Many IT specialists call the Java language the most universal. It can be used on almost any platform - Windows, Linux, Mac, mobile operating systems, web development. The Java language is relatively difficult to learn, but once mastered, a programmer will be able to solve a wide range of problems.
Javascript is not directly related to Java, despite the similarity in name. It is used mainly in the field of web development. Using Javascript, you can implement flexible configuration of web pages in terms of appearance, controls, animations and other features. Therefore, for those programmers who decide to delve into website creation, learning Javascript is a must. Similarly, web development is the main application area of PHP. It is not difficult to learn and is very functional.
What should a programmer know about Python and Ruby? First of all, despite the ease of study, they are used in a variety of areas. For example, Python is actively used by developers of the largest online corporations - Google, Facebook. The Ruby language is great for small startups, but not only - for example, large projects such as Slideshare and Groupon have experience using it successfully.
The mobile application market is one of the most dynamic and profitable today. If a programmer wants to get comfortable on the iOS platform, then he should learn the Objective-C language - it, as we noted above, was specially created for developing the corresponding type of software. If a person is closer to the Android device market, then he needs to learn Java.
The SQL language is one of the most common for working with databases. It is relatively easy to learn, but its knowledge will always be useful to a specialist planning to build a career in a large corporation.
A career as a programmer attracts many people. This is due not only to a high salary, but also to the opportunity to take part in the implementation of interesting projects that can be significant not only for an individual company or startup, but also for the whole country and the global IT market.
Let's study what necessary knowledge and skills a person planning to become a programmer should have.
What should a novice programmer know?
There is a common point of view that only a specialist with a mathematical or technical education can develop competitive software. It is for this reason that subjects of the relevant profile must be taken as exams for IT specialties in universities. It can be noted that mathematics is not a criterion for a programmer’s viability, but a necessary tool. Knowledge within this discipline does not guarantee that a person will be able to create high-quality software, but without it it will be difficult for him to master even the most basic software development languages.
This text appeared as a response to the standard reaction of “real programmers” in response to my words that I am a 1C programmer. “Ah-ah, 1c-nick, what kind of programmer are you, a script writer at best. You dig into your accounting and for some reason consider yourself programmers. Do a real programmer know how much everything you should know?”
When I ask with interest what exactly a REAL PROGRAMMER should know, I usually get in response some specific problems of the particular programmer with whom I am talking at that moment. Moreover, they are presented almost as the true essence of all programming as such. Well, something like - “If you don’t know how to use semaphores in Delphi, you’re not a programmer.” Or - “if you don’t know how hash tables work, you’re not a programmer.” I got tired of this, I scoured the Internet and decided to collect in one post everything that a REAL PROGRAMMER should know, according to the REAL PROGRAMMERS themselves. List broken down by knowledge section under the cut
MATHEMATICS
Numerical methods, dichotomy/Newton's method, inter- and extrapolation, splines, Gauss/Jacobi/Seidel method, QR and LU decomposition, SVD, least squares method, Runge-Kutta methods, Adams method, Newton-Cotes formulas, Ritz method, Bubnov method -Galerkin, finite difference/element method, FFT/STFT, convergence and stability, l-bfgs and other quasi-Newton methods, adagrad, PARAFAC, cassowary, interior point methods, variational methods for Bayesian inference, nesterov, automatic differentiation, alternating least squares, what every computer scientist should know about floating point arithmetics by Goldberg, Nocedal & Wright/Boyd & Vandenberghe
Algorithms, Knuth-Graham-Patashnik/Zorich/Winberg, Spivak/Dummit-Foote, mathematical analysis, linear algebra, complex analysis, functional analysis, differential geometry, number theory, differential equations/integral equations/calculus of variations/optimal control, generating functions , series, combinatorics, probability theory/mathematical statistics/random processes/queuing theory, Markov chains, integral transforms (Fourier, Laplace, Wavelet), NZQRCHOS, mathematical packages (Mathematica, Maple), category theory
Information theory, compression, Huffman, RLE, BWT, LZ, error correction codes, lossy compression (images, audio, video), information entropy, Shannon's formula, Kolmogorov complexity, maximum entropy problem, kullback-leibler divergence, elias/shannon- Elias encoding
Discrete mathematics, K2, Post's theorem, circuits, finite state machines (DFA and NDKA), Kalashnikov assault rifle, cellular automata
Cryptography, Schneier/Yashchenko, Kerkhoffs principle, symmetric (DES, AES), asymmetric (RSA), PRNG quality, Diffie-Hellman algorithm, elliptic curves, hashing (MD5, SHA, CRCn), DHT, cryptographic strength, crypto-attacks (grandmaster attack) , WEP/WPA/WPA2 and attacks on them, digital signature and certificates, PKI, HTTPS/SSL, zero-knowledge proof, threshold scheme, murmurhash/cityhash, DKIM
Quantum computing, Shor's algorithm, quantum cryptography
GENERAL BASICS OF PROGRAMMING
Multithreading, dining philosophers, deadlock/livelock/race condition/starvation, atomicity, processor lock instructions, memory model/barrier/ordering, CAS or LL/SC, wait/lock/obstruction-free, ABA problem, writing lock-free containers, spin-lock, TLS/per-thread data, Amdahl's law, OpenMP, MPI, map-reduce, critical section/mutex/semaphore/condition variable, WaitForSingleObject/WaitForMultipleObjec ts, green thread/coroutine, pthreads, future/deferred/promise, actor model, parameter server, RDD (as seen in sparks), downpour SGD, wait-free, stackful vs stackless
Computability, Turing machine, Markov normal algorithms, Post machine, Diophantine equations of Matiyasevich, Church lambda functions, partially recursive Kleene functions, Sheinfinkel combinatorial programming, Brainfuck, equivalence of Turing bogs, stopping and self-applicability problem, countability of a set of computable functions, RAM machine, Tarski algorithm, SAT/SMT solvers, theory of formal systems, interactive proofs, Lewin-Cook theorem, 3SAT, PSPACE = NPSPACE,
Algorithms and combinatorial optimization, Cormen/Skiena/Sedgwick/Knuth/Aho-Hopcroft-Ulman/Papadimitriou/Shriver-Goldberg/Prep Arata-Shamos/e-maxx.ru, data structures, algorithms, complexity, Landau symbolism, Acra's theorem Buzzy, time-space tradeoff, complexity classes, NP-complete problems, KMP, graphs and trees, flows in networks, Kirchhoff matrix, search trees (especially RB-tree and B-tree), occlusion detection, heap, hash tables and ideal hash, Petri nets, Russian peasant algorithm, Karatsuba method and Winograd-Strassen matrix multiplication, sorting, greedy algorithms and matroids, dynamic programming, linear programming, diff algorithms, randomized algorithms and fuzzy search algorithms, pseudo-random numbers, fuzzy logic, gusfield (suffix tree, string alignment), motif search, scanning line, cache oblivious, funnel sorting, VEB-layout, root optimization, algorithms for dynamic graphs , calculation models (RAM-machine/pointer machine/decision trees, etc.), algorithms in memory hierarchies/streaming algorithms, time forward processing, range & rank, LSM-trees, buffered a-b-trees, toku trees, persistent structures , succint structures, lossy structures (bloom/bloomier filter, hash-tables with false positives), locality sensitive hashing, space-time tradeoff in hash tables, scheduling strategies
Machine learning, Tibshirani/Bishop, approaches to AI modeling, retraining/cross-validation, Bayesian networks, neural networks, Kohonen networks, Restricted Boltzmann machine, gradient descent/hill climbing, stochastic optimization (Monte Carlo method, annealing method, genetic algorithms, ant algorithms ), SVM, gradient boosting, cluster analysis, principal component method, LSH, reinforcement learning, MDP, information retrieval/data mining/natural language processing, computer vision, Szeliski, OpenCV, image processing, OCR, Sobel filters, Haar cascade, Viola-Jones framework, SURF, introduction to the psychophysiology of vision, IPython/pandas/scikit-learn, (ME)HMM, CRF, label bias problem, stacked NN, LeToR, factorization machines, autoencoders, RNN/CNN, separate tasks are better instead of NLP (language modeling, co-reference detection, text chunking, POS-tagging, probabilistic parsing, statistical machine translation, misspell correction, question answering, NER, collocation detection, text summarization, speech recognition, fact extraction, sentiment analysis), efficient softmax calculation , feature engineering/selection, quality estimation, Manning/Jurafsky/McCallum/Koehn, latent topics (LDA, Chinese restaurant, pLSI), parallel coordinates, vowpal wabbit, NLTK, structured learning, EM algorithm, contrastive divergence, optimal brain surgery, belief propagation, semi-supervised learning, inductive vs transductive learning, kernel trick, discriminative/generative pairs (as seen by Ng & Jordan), sequence to sequence learning, bagging, social graph analysis, recommender systems/collaborative filtering, multimodal learning
GENERAL PRINCIPLES OF WRITING PROGRAMS
Architecture and code style, McConnell/Fowler/Leblanc/Gamma/Alexandre Rescu-Sutter/Butch, defensive programming, patterns, SOLID/GRASP/KISS DRY SPOT/YAGNI, UML, OOP (Smalltalk), OOD/OOA, code metrics, uncle Bob
Development methodologies, Waterfall/RUP/Agile/Scrum/Kanban/XP, TDD/BDD, CASE
Development tools, IDE, IntelliSense, debuggers (VS/Olly/WinDbg/kdb/gdb) and tracers (strace/ltrace), DWARF debug information format, disassemblers and decompilers (IDA/HexRays/Reflector), version control systems (SVN, GIT), merge/branch/trunk, file and branch naming systems, continuous integration, ant, code coverage, static analysis (lint, cppcheck), dynamic analysis (valgrind, fuzzing), software verification and validation (Frama-C, RAISE ( RSL), Coq), profiling, bug trackers, code documentation, build systems (CMake), package managers (NuGet)
Frameworks, Qt, moc and meta-information, slot-signal concept, Summerfield-Blanchette/Schlee, PoCo, industrial libraries: GMP, i18n, lapack, fftw, pcre
GUI design and information presentation, Raskin/Tufty, usability, design and typography basics, Fitts' law, layout basics, LaTeX, data visualization algorithms (as seen in d3), subpixel rendering
Testing, unit tests, functional, load, integration testing, UI testing, mocks/stubs/spies, fixture, smells and test patterns (Osherove/Meszaros)
PROGRAMMING LANGUAGES
General understanding of programming languages, grammars, Chomsky hierarchy, Myhill-Nerowd theorem, pumping lemma and Ogden's lemma, Kleene algebra, NDKA → DKA, algorithmically undecidable problems in formal languages, Dragonbook, Friedl, regexps and their complexity, PCRE, BNF, Boost.Spirit + Karma + Qi/Ragel, LL, LR/SLR/LALR/GLR, PEG/packrat, yacc/bison/flex/antlr, static code analysis, compilation/decompilation/obfuscation/deobfuscation, Clang/LLVM/XMLVM /Emscripten, GCCXML, OpenC++, building virtual machines, JiT/AoT/GC, DSL/DSEL, on-stack replacement, type checking/type inference algorithms, CYK parser, advanced compiler design and implementation by Muchnick
Assembly language, Zubkov/Hyde/Drepper/Kaspersky/Fog/Abrash, x86, FPU/MMX/SSEn/AVX, AT&T and Intel syntax, masm32, macros, stack, heap/heap managers, calling conventions, hex codes, machine data representation, IEEE754, little/big endian, SIMD, hardware exceptions, interrupts, virtual memory, reversing, stack and heap disruption, return oriented programming, alphanumeric shellcode, L1/L2/RAM/page fault and their timing, ARM assembly language
C++, standard, Comeau, 1TBS, Stroustrap/D&E/Josattis/Vanderwood, Dewhurst/Meyers/Sutter, RAII/copy-and-swap/exception-safety, rule of five, Alexandrescu/Abrahams-Gurtovoy, type erasure, CRTP, NVI, SFINAE, Koenig lookup, Duff"s device, Boost, Sick-Lumsdain/Karlsson, TR on C++ performance, Stepanov test, forwarding problem/move semantics, SPECS, GotW, Meyer"s singleton, cppgm
C++ compilers, features of the implementation of the standard, implementation restrictions, intrinsics, differences between standard libraries (containers, rand), ABI, implementation of virtual functions, virtual inheritance, exceptions, RTTI, switch, pointers to functions and methods; optimization, copy elision (RVO, NRVO), sizeof on various platforms, compiler and environment definitions, __declspec, compiler switches, empty-base optimization, static and dynamic linking, mangling, distributed compilation, precompiled header, single compilation unit, (strict) aliasing/restrict, inline/_forceinline, volatile, fast calculation of mathematical functions via bithaks, linkers & loaders by Levine
Application programming, C#/F#, Shildt/Troelsen/Richter, generics, yield, linq/plinq, reflection, AST, WCF, WinForms/WPF/Silverlight, AOP, logging frameworks, .NET assembly, Scala, Horstmann/Odersky, pattern matching , macros/quasi-quotes
Functional programming, Haskell/Ocaml/Scheme/Alice or Oz, SICP/TaPL/YAHT/Purely Functional Data Structures/Harrison-Field, HOF (map/fold/filter), Hindley-Milner type system, monads, typeclasses, ADT, dependent types, laziness/energy, logic programming (Prolog or Mercury), competitive programming (Erlang or Oz)
Web Programming and Scripting Languages, Flanagan/Zend PHP5 Certification Course + Study Guide, Apache/nginx, CGI/FastCGI, PHP/Zend Framework/ReactPHP/Zend Engine/Doctrine or Propel/CodeIgniter or Symphony or Yii, Python/Django/Twisted , Ruby/RoR, ASP.NET MV*, JavaScript/jQuery/React/Google Closure/ExtJS/node.js, OOP in JavaScript, HTML5, CSS3/table and block layout, RSS, canvas/WebGL, Ajax/WebSockets, questions security (XSS, SQL injection, CSRF), highload, C10k problem, SWIG, CDN, shadow DOM, browser twists, real time bidding/trading, anomaly detection, single page apps architecture, web crawler design, web/social graph random walk, asm.js and compilation in js, v8/spidermonkey internals, PaaS/IaaS, SPDY
DATABASE
Databases/Distributed Systems, Gruber/Date, ANSI SQL, T-SQL, ODBC, MySQL/PostgreSQL/MS SQL/BDB/SQLite/Sphinx, stored procedures, triggers, Codd/A algebra, Tutorial D, normal forms, query optimization and execution, index data structures, transactions and ACID, Brewer's CAP theorem, graph DB, document store, wide column store, key-value storage, distributed systems theory, CRDT, net split problem, consensus protocols, sharding theory/ replication, ORM (C++ ODB), ERD, OLAP, semantic network, triplestore, RDF/Turtle, SPARQL, OWL, Semanticscience Integrated Ontology, reasoner, DBpedia, big table/hbase vs. dynamodb/cassandra/riak, 2/3PC, chubby/zoo keeper, leader election (paxos/raft), hdfs/gfs/glusterfs, deduplication problem, causality detection (vector clock/stamps), R/W quorum, load balancing, device indexes search engines, event sourcing, CRDT, protocol design and communication principles, from the point of view of evolution, extensibility, reliability, design software interfaces(API)
OPERATING SYSTEMS
Operating systems, Silberschatz/Richter/Solomon-Russinovich/R obachevsky/Vakhalia/Stevens/Tanenbaum/Lov e/Linux Kernel Internals, memory manager, heap manager and its device (LAL/LFH/slab), device manager, process manager, context switch, real and protected mode, executables (PE/ELF/Mach), kernel objects, debug mechanisms (strace/ptrace/dtrace/pydbg, Debug API) and minidumps, bash, network stack and high-performance servers, netgraph, CR0, IPC , window subsystem, security system: ACE/ACL and access rights, virtualization technologies, RTOS (QNX), driver programming, IRQL, IRP, file systems, BigTable, NDIS/miniport/FS drivers/filter driver, Mm-, Io-, Ldr-functions, DKOM and rootkits, GDT/IDT/SDT, Windows/Linux/BSD kernels, POSIX, TRIM
Formats, XML/XSLT/XPath/XMLStarlet/DOM/SAX, RTF/ODF, JSON/BSON/bencode, YAML, JPEG/PNG/WebP, AVI/MPEG/RIFF/WAV/MP3/OGG/WebM, SVG, Unicode, single-byte encodings/UTF-8/UTF-16/UCS-2/UTF-32, length problems and comparison of Unicode strings, base64, markdown
Component-based models, Rogerson/Tavares, COM/OLE/ActiveX/COM+/DCOM RPC, ATL, apartments, monikers, MIDL, XPCOM, CORBA, TAO, D-Bus
Network, Stevens, OSI model/Internet model, Ethernet, TCP/IP, TCP window, Nagle algorithm, sockets, Protocol buffers/Thrift/Avro/ASN.1, AMQP, ICMP, routing/BGP/OSPF, ARP, Mitnik attack, syn flood, HTTP/FTP, P2P/DHT, DHCP, SMB/NBNS, IRC/XMPP, POP3/SMTP/ESMTP/IMAP, DNS, WiFi/WiMax/GSM/CDMA/EDGE/Bluetooth/GPS, ACE, Wireshark
HARDWARE
Hardware, Horowitz-Hill/Titze-Schenk, semiconductor electronics/spintronics/photonics, transistor, trigger, circuit design, microcode, processor technology, logic synthesis, static timing analysis, FPGA, Verilog/VHDL/SystemC, SISAL, Arduino, devices memory (ROM → EEPROM, RAM, SSD, HDD, DVD), RISC/CISC, Flynn's taxonomy (ID), Princeton and Harvard approach, processor architectures, x86 architectures, VID/PID
Processors, pipelining, hyper-threading, Tomasulo algorithm, speculative execution, static/dynamic branch prediction, prefetching, multiple associative cache, cache line/cache miss, clock cycles, protection rings, memory in multiprocessor systems (SMP/NUMA), timing memory, intel optimization manuals, performance counters
___________________________________
Well, is it impressive? I wonder if there is at least ONE PERSON in the world who really knows all this?
Programming skills can be useful not only for those who want to create programs or websites professionally. Ilya Shchurov, Associate Professor of the Department of Higher Mathematics at the Higher School of Economics and a teacher at the Center for Continuing Education of the Faculty of Computer Science at the National Research University Higher School of Economics, spoke about how the ability to write code can make life easier. T&P publishes his lecture notes.
Ilya Shchurov
Associate Professor of the Department of Higher Mathematics at the Higher School of Economics and Lecturer at the Center for Continuing Education of the Faculty of Computer Science at the National Research University Higher School of Economics
You can come up with many classifications, but first of all I would divide programming into two broad categories: programming for someone else, where you write a program that people will use, and programming for yourself. Professional programming is mostly an activity for others, and I wouldn't say it's always enjoyable. Regardless of whether you were paid for the program or you write free software that anyone can use, a huge number of people will complain that something doesn’t work for them, and there will always be more of them than those who praise you. And programming for yourself is a very pleasant activity, and today we will discuss exactly that.
This year's survey of professional programmers found that 81% of them code as a hobby. This means that programming is fun, that it's fun as well as work. You can use ready-made programs, and 95% of the time you will do this, even if you are a professional programmer. But in any field there are problems that no one has solved before, and the ability to program allows you to solve them much more efficiently. One day I was in a call center and I was asked to join two tables. The person who assigned me this task expected me to start copying cells one by one from the first table to the second. I transferred a couple of records, got tired of it, and wrote a short script that took data from one table and filled out a Google form for me, which is not very difficult. I liked it, but what I liked most was that my colleagues looked at me as if I had some kind of magic.
Writing code is interesting, but on the other hand, it is a challenge. You interact with a computer, and very often this interaction, especially if you master new technology, new language, looks like that. You write code, you think you wrote it correctly, but the computer tells you that you have a syntax error. Indeed, I forgot the semicolon, corrected it, ran it again. And the computer says: “Close the bracket.” After several such iterations, the program begins to work, and it becomes clear who is boss. The fact is that both the programming skill and the process of learning it have some side effects (including positive ones).
1. Extreme Leadership Experience
Computers are very stupid compared to people, they understand everything literally, and if you have learned to drive a machine, then most likely you can cope with guiding any people.
2. New approach to information
You begin to look differently at information processing, organization of information flows and management. For example, when collecting data sets, you already think about whether they are suitable for subsequent automatic processing. This is very important if you have a large organization or a project with many information flows that you need to work with efficiently. If you have experience with automation, you will quickly understand in what form you need to receive information in order to then deftly process it.
3. Professional communication
If you learn to program at least a little, it will be much easier for you to communicate with programmers. It is useful to understand at least at a basic level how the IT world works and to communicate in this area without intermediaries. People learn languages to better understand another culture, and programming languages learn technology.
4. Responsibility
Why can programming be dangerous? The first reason is “tyzhprogrammer”. If suddenly someone finds out that you know how to program, you will be bombarded with requests: “Reinstall the operating system for me, please, you’re a programmer,” “Fix the kettle, you’re a programmer,” and so on. This is not the worst problem, there are worse ones. For example, in 2001, during my first year, when the Internet was still slow, I decided that I needed to do something to exchange information with friends faster. I thought: there is mail, and it works. Then I created a separate mailbox for our party and wrote a script. The robot went into this mailbox, took the letters that came there, and forwarded them to everyone who was subscribed to this thing. This is how Google groups work now. If I wanted to write to everyone, I sent the letter to this general mailbox; if someone wanted to answer, he answered it, the letter got to everyone, and something could be discussed.
But someone’s mailbox is full, and when the mailbox is full, the mail server, in response to any letter, sends a message, which is also a letter. It also ended up in the general mailbox, my script sent it to all addresses, including the one that was full. Mail server generated a new response and so on. As a result, on Sunday morning I was woken up by a call from my friend, who carefully said: “Perhaps there is some problem there, because I have 6 thousand letters in my mailbox, and their number is growing.” Nothing too bad happened, but it was a problem. Then I realized that the code could easily get out of control and cause trouble, so I had to act carefully.
This is a story like in “The Little Prince”: you are responsible for those you have tamed. People and processes depend on the code you write. That is, as soon as you do something useful for others, the cost of error increases.
How to learn?
There are two opposing points of view on this topic. First: learning programming is very easy; basic commands can be mastered in three days. But there is a high probability that when a person encounters difficulties, he will decide that he was deceived and programming is not for him. Programming is not easy, difficulties arise. One of the reasons for this is that when you program, you learn new technologies every time, which is always a pain.
The opposite opinion is that if you haven't been programming since you were in school, then there's no point in starting. This is also not true. Programming takes effort, but the field is open to entry even if you've never done it before.
It is likely that the problem you are faced with has already been solved and the solution lies somewhere. Sometimes figuring out how it works is harder than writing it again. This is a standard programming problem, but for this we have Stack Overflow, one of the main inventions of mankind in the field of programming. This is a site where developers share their experiences and answer each other's questions. Each participant has their own level of reputation, everything is very well designed, so simple questions can be answered within ten seconds. This helps a lot. In the modern world, you don't just write a program - you simultaneously use a huge number of programs and tools that other people have already created.
A good way to learn to program is to set yourself a problem that you would be interested in doing and then try to solve it. Of course, there are many online courses - read the reviews to choose the right one. A first programming language is difficult because you have to restructure the way you interact with computers and analyze processes. There are no universal answers, everything is very individual. Some people just need to read the documentation, look at the code examples, and everything is clear. In other situations, it is good to have a mentor who can answer basic questions. Here are some tips that seem important to me.
1. The most The best way to understand something - find a working piece of code, start modifying it and study what happens. This should be done after you have understood the basic syntax. Customize the code to suit your needs or just experiment.
2. If you're just learning to program, don't try to write a lot of code right away until you can correctly explain what you want. This is necessary so that the computer executes commands clearly and in small steps. Every time your experiments should end not with you accidentally stumbling upon the right solution, but with an understanding of why and how it works.
3. Don't worry about math. It is advisable to know what a remainder is when a number is divided by another number, but it all depends on the tasks you are faced with. Of course, if you want to cleverly process data, then you need mathematics to the extent required for such processing.
4. Don't be afraid. When you start programming for yourself, you probably won't write the kind of code that professional developers will like. They will say that this is not the way to write it, that it is redundant, that such code will be difficult to maintain, and so on. They'll probably be right. But if you are writing for yourself and if you are just starting out, it is normal that your first attempts are not texts of the level of Leo Tolstoy. If you write a program that will work and solve your problem, then that's good.
There is an opinion that, given the development of artificial intelligence and machine learning, programmers will soon not be needed: computers will learn to program themselves. But it seems to me that this is not so. As long as there are problems and as long as it is necessary to explain how to solve them, programming will exist. Of course, programming is evolving a lot, it has changed a lot over the past 20 years. But because computers have become smarter, there are no fewer developers - on the contrary, there are much more of them. And it seems to me that the same thing will happen further.
Loading...