Transcription
In 2026, ignoring the standard subsystem library is no longer just a mistake. It is, excuse me, a clinical diagnosis. Do you want to work as an adult professional, earn serious money and the respect of colleagues, or do you want to remain a graduate of a remedial programming school your whole life? The question is rhetorical. What do I think about this? How is proper architecture structured? And what do confectionery products have to do with it? I will explain immediately. I welcome you without exception. The day before yesterday, as part of operational-search activities for personnel recruitment, I looked into the code of a young prodigy. A picture. I will report to you, my respects. Hair stands on end even for seasoned operatives. Instead of taking a ready-made, debugged, lubricated tool, the citizen, with persistence worthy of a better application, invents a square wheel, saws with a file, puffs, spends the client's money, and the result is a crooked fake made of acorns and matches. Let's be frank. The conversation today will be long and thorough. We will not be talking about giggles and chuckles, but about your career and your qualifications, and, as a consequence, the thickness of your wallet. So, pour some tea, grab something sweet, lean back in your chair, and delve in. It is almost 2026. And I observe the same sad picture. Newcomers arrive. Their eyes are burning, enthusiasm is overflowing, their fingers are flying across the keyboard, they have learned the syntax, they have learned to make requests in the console, and then they immediately hit their foreheads against a concrete wall. That's it. Why? Because their heads are full of oatmeal. They try to write code the way our great-grandfathers did in the days of Tsar Pea. Slapped together a form on the fly, attached a handler to a button, wrote "directory.create element" and it's done. I'm a programmer, bring me my money. I am forced to disappoint you. Modern 1C is no longer about accounting for potatoes in Ashot's kiosk. It is suddenly an enterprise-level ERP system. Holding management. Billions are churned here. Thousands of users work simultaneously here. And the approaches here have changed radically. Let's recall how code was written in, say, 2010. Regular forms, thick client. Remember that? We could even write queries directly in the form module, we could access the database from anywhere. Client and server were merged in a single ecstasy. It was the Wild West. No laws, no rules. Fast, dirty, works, and into production, and that's that. And then came the efficient managers and technological progress. The managed interface appeared. A strict separation between client and server occurred, and then asynchronous operations were introduced, and modal windows were abandoned. And now, to simply open a selection form and get a result from it, you can't just write "open form modally." You need to know about notifications, notification descriptions, call context, and control transfer. The complexity of the platform has not doubled, it has increased tenfold. And here many make a fatal mistake. They try to fight this complexity manually, like an old hero from a legend. If you ignore BSP, you are trying to assemble a modern Mercedes in a garage with a rubber mallet and a curse. While others assemble it from ready-made blocks on a robotic assembly line. The result is predictable. Your "coupe" will fall apart at the first turn. You won't withstand the competition in speed and quality. By the way, I already have a video on my channel about the top most useful BSP functions. Add them to your list and be sure to watch this video via the link in the description. Excuse me, but I will sometimes interrupt the speaker for a very, very short time to show you the main practical life hacks. For example, you want to download the standard subsystem library. Well, it's good if you have paid access to the site, because without paid access it's not available there, unfortunately. This is what paid access looks like. That is, we go to this site releases.ru and total. Scroll down, down, down, down, down. Here is the standard subsystem library of different versions. We need version 3.1 for now. Go here. And here are different versions. And we download them. When you download a version, you will discover an interesting thing. The thing looks like this. That is, here are all these files that are included in the delivery. What do we need to apply? Let's start with the demo. Demo CF or CF, as it's also called. This is something from which you can get a demo database. If you look into the installation and usage guide for the standard subsystem library, which is also on the ITS website, and also in the paid section, then regarding these demo databases, it says approximately the following: that these demo and demof are intended solely for you to be able to see and touch in practice how this standard subsystem library can be used. And this instruction also often contains links to this demo database. That is, in practical application, for example, on a working database, you will not be able to use it, but you can deploy this demo database, look inside it. This is approximately how it will look. Here it is, please, I have deployed it. There are some subsystems here, in which some documents are created. And if you look into the configurator itself, you will see some things here called demo, demo, demo, that is, underscore demo. You will also see documents with underscore demo. They are intended for you to be able to practically see, try, experiment with an already ready database, without doing preliminary setup and similar things. So, we've dealt with the demo database. So, what else do we have? We also have International CF and just 1S V8 CF. These two configurations are precisely intended for mass, so to speak, use, for mass implementation and updating of the standard subsystem library in your custom configurations, and sometimes they can also be used for partial updates of your, perhaps, old standard configurations. How do they differ? Firstly, you cannot use these CFs to get any working database. That is, you cannot open an empty database, load this CF or that CF into it, and then, you know, load everything into it and press F5, and your database would work. That won't happen. Moreover, you won't even be able to update the standard subsystem library using these CFs in such a simple way. What are they for? They are for implementing the standard subsystem library according to the instructions. And the instructions are very large and are on the ITS website, respectively. We will not consider them all now. If you wish, you can familiarize yourself with them. There are also many materials on the internet. Just remember that this CF 1SV8 is the complete standard subsystem library. It contains everything intended for the Russian market, because I downloaded the version intended for the Russian market, that is, taking into account our regional specifics. And from International, many parts related to the Russian market have been removed. It contains less data, it contains fewer subsystems. You can even see from the size: a regular CF for Russia is 65 MB, and an International CF is 62 MB. It is clear that about 5-10 percent has been removed from it. Now you know what is included in the delivery, and you can already roughly imagine what you will have to deal with. The CF files also contain a lot of useful information. There is some documentation here, but the documentation is very extensive, I warn you immediately. There is also an installation guide and all the necessary things. This is wonderful. There are also necessary utilities here that you will need when implementing and updating the standard subsystem library. And now, let's continue with our main speaker's lecture. The era of craftsmanship is over. Accept it. We live in an era of component development. And the foundation of everything, alpha and omega of 1C, is the standard subsystem library. To help you understand how it works, let's use a visual metaphor. Take any modern ERP configuration, complex payroll, trade, or anything else. Do you know what they look like from the inside? Imagine a huge, complex culinary creation. A cake. Our native yellow, multi-layered honey cake. Looking from top to bottom. At the very top are cream roses, berries, beautiful sprinkles, chocolate figures. This is your industry-specific customization. These are your modifications for the specific desires of a particular factory director. A little deeper is the tender, delicious business logic cream, postings, documents, complex cost calculations. And at the very bottom, at the base of this cake, lie hard, dry, baked, load-bearing layers. This is BSP, this is the base, the foundation. Everything rests on these layers. You can change the decorations on top, you can change the taste of the cream, but if, out of stupidity, you try to pull out the bottom layer or start stuffing your raw, unbaked dough there, the cake will fall apart. Newcomers categorically do not understand this. They come to a project and start sculpting their crooked little layers on the side of the main cake. A real-life example. A trivial task. You need to attach a scanned contract to a customer order document. What does a dilettante do? He creates a directory, stored files. He writes a download button. He struggles with binary data, with streams, with extensions. He spends 3 days on it. Why? BSP has a ready-made, perfect layer. The file handling subsystem. It does all this better, faster, safer, and more reliably. It already has preview, electronic signature, versioning, and so on and so forth. Another example, you need to send an email notification if an order is overdue. A dilettante writes his own code to connect to SMTP, hardcodes passwords, and BSP already has all this done correctly. Baked and ready to use with support for Open Authorization, error logs, and resending. If the internet suddenly flickers, face the truth, open a job site, type "leading 1C programmers." What do they write there? Excellent knowledge of BSP. Why do employers write this? Not because they like the taste of this cake, but because business counts money. If you don't know BSP, you will spend paid time baking what has already been baked by the 1C company. Hiring someone without BSP knowledge means losing money. Want a high salary? Learn the fundamentals. I will briefly interrupt the speaker again and tell you where to get the standard subsystem library if you don't have paid access to the ITS website. There is a special site on GitHub where this entire library is located, but in the form of files. Here is the address, I will leave it in the description and on my Telegram channel. Here we have the latest version, here it is 3110, and we can download it. The source code is downloaded here as an archive. I have already downloaded it in advance. This is the kind of archive it contains. If we look inside the archive, we will see many, many folders like this. And in this folder, there are various XML files. That is, respectively, these are all the modules intended for implementing our standard subsystem library, but they are in this form. Therefore, we have to work a little manually to get a ready-made standard subsystem library in the end. Let's unzip it. We also need to prepare a completely clean configuration. I have already deployed it. You should already know how to create a clean 1C configuration. That is, there should be nothing here. Just create a clean database. And now we need to go here. Configuration, load configuration from files. And here we select our XML files. Then click load. The files are loaded, and now all the necessary modules containing the standard subsystem library will appear. The only point is that this is not the latest version. The latest version is, of course, on the ITS website. That's it, the version has been loaded. Click F7, the configuration is updated. Now we have all the modules from the standard subsystem library, for example, general purpose, my favorite, and so on. We have everything else, use it. Next, what else can you see here? Modules with the suffix "service." These "service" ones. They cannot be used, even if they have export methods. Let's go in here. You see, it says "export." It would seem that theoretically it can be used as an API in some of your utilities, to refer to it when defining settings. There is an export, right, but it seems like it can be used, but it's a service one. Therefore, according to the rules, which are clearly stated on ITS, we have no right to use these "service" ones. Why? Because in the future, 1C reserves the right to change these things at any time without prior notice. Also, pay attention to the following. Here we have a general purpose module. I opened it, and there is no word "service," right? But nevertheless, if we go inside, we will see that there is a section called "service procedures and functions." We should not use them for our own purposes as an API, even if there is the word "export" here. Here is our usual programming interface. That is, everything that is inside this section, we can use for our own purposes, calling them from our utilities, documents, reports, and so on. And now let's continue listening to our wonderful speaker. Well, let's move away from cooking a bit and talk about you as a specialist, about improving your brain. Many, when opening BSP in the configurator, fall into a stupor. Panic, cold sweat. Oh, my goodness, there are a million modules. Damn, it's impossible to figure out. How scary. Calm down, stop the panic. I suggest approaching it from a different angle. Change your approach. Look at BSP not as a directory, but as a textbook. This, I believe, is the best textbook on programming in 1C that exists in nature. It was not written by students for food, it was written by methodologists, platform developers, people who, you could say, created this language. The elite. Every line of code there contains decades of experience. I'll give you a practical task. The exercise is called "BSP Code - Your Mentor." Allocate 15-20 minutes a day. Instead of watching cat videos or scrolling through your feed, open the configurator, find the general module called "general purpose," and start reading it sequentially, like "War and Peace." Don't look for solutions to specific problems at first, but study the style and handwriting of the master. Stop at a procedure and start asking yourself questions. Why was the variable named exactly that way? Why is a structure used here, and a dictionary in the adjacent procedure? What is the deep intention? How do they handle errors through try-catch or through special preliminary preparation and condition checking? And at this moment, soulless lines of code turn into your personal, free, Synergy-level mentor. You start seeing design patterns. Aha. Here, the developers used the strategy pattern to substitute printing algorithms on the fly without rewriting the main code, and here is a clear adapter to connect old code with a new interface. And here is a factory to create objects without knowing their exact type. After a month of such thoughtful reading, your own code will change beyond recognition. You will stop writing 500-line scripts in one procedure that even the devil can't figure out. You will start breaking code into logical blocks. You will start naming functions correctly. You will stop being a coder. You will start becoming an engineer. Second exercise. Search the internet for which BSP subsystem can handle your task. Artificial intelligence is now built into all search engines, and it will tell you how to apply standard subsystems to your task and whether they exist at all. When adding a new document or directory, look into the standard directory and see how standard commands are connected there, for example, for connected print forms, service button output, and so on. Now let's move on to the meat, to the harsh technical part. How to work with this monster and not get injured, there is one main ironclad rule. Write it down in your subconscious. Hang it in a visible place. The rule is called the Facade Pattern. Let's go back to our honey cake. Imagine that this cake is in an expensive confectionery shop under glass in a display case. You can look at it, drool. You can ask for a piece, and it will be carefully served to you through a special window. But you are strictly forbidden to open the display case, reach in with dirty hands, and poke at the filling. This violates sanitary norms. The 1C company has clearly divided all the library code into two zones: public, what's on display, and service - this is the filling and the kitchen. Service code is the internals, it's the guts of the system, so to speak. There can be complete hell and chaos there, complex mathematics, temporary tables, unoptimized queries that the system needs here and now. This is easy to distinguish. The name of the module or procedure contains the word "service," or the module is located in the "service" subsystem. So, for you, this code does not exist. You are strictly forbidden to call it directly. Why am I so harsh? Many think: "Oh well, I'll just poke it once, no one will notice, it works." I'll tell you an instructive, tragic story from practice. We had a talented young man on the project, let's call him Dima. He was assigned the task of implementing mass printing of documents in the warehouse during shipment. Dima dug into the bowels of BSP, into the cake filling with his fingers, rummaged there, and found a procedure in the general module of printing management, a service one. The procedure did exactly what was needed. It formed an array of tabular documents. Dima was pleased, called it, and completed the task. The client is happy. The warehouse works like clockwork. Six months, everything is fine. And then, we installed a planned BSP update. A regular release, nothing special. And on Monday morning, the warehouse completely stopped. Trucks are standing, a queue to the horizon. Invoices are not being printed, drivers are swearing. Directors are calling. Losses are millions per hour. We go into the debugger and see an error. Method not found. It turns out that in the new version, 1C decided to re-bake these very layers. They optimized printing and split this service procedure into two different ones. They changed the parameter set. They had every right to do so. The module is a service one. They promised nothing to anyone there. The warranty on the filling does not apply. The result: colossal losses, gray hairs for the warehouse manager, and a pale face for the demon, who, with trembling hands, rewrites the code under the shouts of his superiors. And this could have been avoided if he had used the method from the printing management module without the "service" designation. There were no changes in the public interface, because it is a so-called contract. Remember, don't poke the cake. Take only what is given through the API window. Service code is a minefield. It will blow up today, or tomorrow. You will ask: "Well, okay, I can't poke inside, the glass is bulletproof." But how then to add my own ingredients to this cake? How to connect my new directory with this huge power? 1C architects are not stupid people, they have thought of everything. There are three legal, standard ways to enter this ecosystem. Method number one. Definable types. The most sensible and most enjoyable method. I call it type magic. Suppose you have created a "Request for Expense" document and want users to be able to attach files, scanned invoices, contracts, and so on, to it. In the old paradigm, you would create a new directory, "Request Files," write the loading code, which is long and tedious. But in BSP, you do something like this. You go to the metadata tree, find the definable type "Owner of attached files," open its composition, and check the box next to your "Request for Expense" document. Then you copy a couple of code snippets into the form module and set the checkboxes in the data types. How this is done is written in the large and beautiful instruction on ITS. And that's it. The system understood. Aha. Files can be attached to this layer. A button has automatically appeared in your form. A selection window opens with a paperclip. Drag and Drop works. You haven't written the storage logic, you've just connected to the type. This is called dependency inversion. You are not dependent on the files module, but the files module is ready to accept any of your objects. Method number two is redefinable modules. This is for cases when BSP wants to ask for your advice. For example, at the start of the system, you need to initialize some of your global parameters, or when saving a partner, check for duplicates according to your specific rules. For this, there are modules with the postfix "redefinable" in the configuration. They contain empty procedures. Attention! Watch my hands! You never call these procedures yourself. Never. BSP calls them. This is a classic callback. Principle: don't call us, we'll call you. Your task is to go into this module and carefully write your code there. And when the necessary event occurs, BSP will look into this module, see your code, and execute it. Method number three. Integration through metadata, data contract, as it's called. This is the toughest option, used, for example, in the contact information subsystem. Here, BSP will give you an ultimatum. Do you want your directory to have cool fields for entering addresses with validation, phone numbers with email and correctness checks? You say: "I want to." Then create a tabular section named "Contact Information" in your configuration and add columns to it strictly according to the list. Type, Kind, Value. Everything is as in the ITS instructions for implementing this subsystem. If you make a mistake in the column name by even one letter, the magic won't happen. But if you fulfill this contract for the data structure, the system will come alive on its own. It will pour its proprietary sauce, validation, and draw beautiful forms onto your directory. I will briefly interrupt the speaker again and show you the functions that I have extracted into a separate utility to demonstrate to you what can be done with this library, with the help of the simplest functions and procedures contained in the standard subsystem library. I created a special utility and made 10 variants of calling algorithms in it, which I implemented both with and without BSP, to demonstrate the code that can be written in the usual way without using the library, as well as the same result that can be obtained using this standard subsystem library. For example, here I will have a procedure for reading object attributes. And we will read them first without BSP, and then with BSP, and output it to the message window. That is, in the first case, I, for example, get the attribute using a dot. That is, I take a link to a document and extract the organization from it. And in the second case, I get it optimized through the library. And the library has our beloved function "object attribute value." It's also "object attribute value" and so on. And there are several different similar functions. I used this particular "object attribute value." And I output it to the message window. That is, using a dot here is a flawed approach. The platform will read this entire object completely first, that is, all attributes, all tabular sections from it. And use only this one attribute. And when we read it using the library, it will extract it using a query, well, I will choose some document for experiments, reading object attributes. We get the same result in the end, but in one case I have already shown you, the first is the unoptimized method, the second is the optimized one, but in the end the result is the same. You can download this utility that I wrote, also via the link in the description and on my channel, and look at it, study the methods I have provided. It will be especially useful for beginners. Perhaps you will encounter something similar, perhaps you have already written something similar without using the standard subsystem library. And here you will have an opportunity to think about whether there are more correct approaches to programming than writing your own square wheels. Here is another interesting function from BSP - it is to set a filter for a dynamic list. That is, if without BSP - this is a common mistake of beginners, they write approximately like this, they make a filter by elements, adding an element there and specifying the left and right values. There are many, many pitfalls associated with dynamic lists. You will most likely not remember them immediately, and even experienced people can forget. But in fact, the filter can be duplicated here, the same filter can be applied with different right values. And because of this, your dynamic list will be displayed incorrectly. And for everything to be correct, you simply use a special function from BSP. Next, among the interesting things, there is also a time interval as a string as input parameters: start time, end time. It calculates the difference between them and, depending on what that difference is, gets a string representation. For example, if it's more than a year, it writes "more than a year." Such a human-readable representation for users. I have provided an example of how to write it manually. And, naturally, I haven't accounted for everything here. Again, you need to do all sorts of checks, that the start date should be less than the end date, and so on. All of that is already accounted for there. And finally, an example that shows the full power of the approach. A mechanism that is often forgotten. The properties subsystem, or additional attributes. Imagine a task. A client comes and says: "I want a 'color', 'size', and 'brand' field in the 'nomenclature' directory." What does a beginner do? He goes into the configurator, adds three attributes to the directory, changes the structure, metadata, and then you have to kick out all users, block the database, apply the update, and the database is huge, it updates for a whole hour. And then the client comes and says: "Give me one more field, 'season'." The beginner goes into the configurator again. This is hell and damnation. But that's how they taught him in courses. They teach the language syntax, and that's correct at the time of study. What does a professional who understands BSP do? He doesn't open the configurator at all. He goes into enterprise mode, opens the "Additional Attributes and Properties" directory, creates the "color," "size," "brand" properties there, and BSP immediately rebuilds the product card form on the fly. It creates input fields itself, controls data types itself. And the coolest thing is that it all works through the mechanism of characteristic plans. The database is not blocked, users continue to work, and the 1C configuration is supported without removing their so-called locks. If you understand how BSP implements this programming without programming, then you will understand the very essence of 1C architecture. You will stop hardcoding what can be moved to settings. And let's summarize a bit. BSP is not just a library. It is the very honey cake that feeds the entire enterprise. You cannot ignore it if you want to work on large projects and earn serious money. You must learn from it, reading code like a textbook. You must respect its rules and not poke the service filling. And you must know how to use its extension tools, types, redefinable modules, and so on. And I understand that there is a lot of information now. Don't try to learn everything at once, you'll burst. Understand the principles, understand the philosophy. Practical task for today: don't write code, open the ITS website, find the "Standard Subsystem Library" section, and just browse the list of possibilities. I guarantee you will find something there that you tried to write manually for half a day yesterday. And then open the configurator and see how this cake is baked from the inside. Develop. Move from writing scripts to designing systems. Become an engineer. There is a shortage of architects in the 1C world now, not coders. Become one of them and don't forget to subscribe to the channel and like this video. Your next practical task is to open the general module called "general purpose" and study all the functions that are there. Write down the ones that seem useful to you on paper, and use at least one of them every day. Thus, in a month, you will already be using several dozen such functions and will be a couple of steps closer to the title of 1C Engineer. And that's all. Like, subscribe to the channel. This was Alexey Lapetsky. >> I used to live peacefully. Cat [music] wrote in silence: "Reports, registers, that's all my business." At the blue conference [music] I attended in spring, and there at registration I met you. You handed me a badge, smiled slightly and said: "Here's the program, Coffee Break [music] don't forget." Although I forgot about the report, and about the standard exchange. I stood, mouth agape [music] by these blue walls across the country. I travel, I catch conferences. Yellow, blue, [music] I love to be at each one. I don't go for knowledge, I don't look for new topics [music] I'm looking for you, beautiful, among IT systems.