Workkit

workkit

As much as construction relies on heavy machinery and robotics, it needs human labor. This has been the status quo for decades — but that’s all about to change. Three-dimensional printing is drastically reshaping labor dynamics. How far will its reach extend? Construction’s Current Labor Dynamics Construction may be one of the most labor-intensive sectors in the world, but it isn’t getting much done. According to the Bureau of Labor Statistics, single-family residential construction productivity dropped by 0.8% from 2019 to 2023, even though hours worked were up by 0.9%. Highway, street and bridge construction fared even worse, with labor productivity down 3.6% despite hours worked increasing by 0.8% in the same period. While industrial and multifamily residential construction saw improvements, that’s still half the sector’s efficiency down. Construction is one of the most labor-intensive industries in the world. It employs 7% to 8.5% of the working population worldwide. Despite various technological advancements, it has remained entirely reliant on human labor — until now. Frankly, the industry is long overdue for change. That’s where 3D printing comes in. This tech operates mostly autonomously, only relying on humans for design, instruction and operation. If it becomes standard, it could permanently reshape labor dynamics. How 3D Printing Impacts Labor Dynamics There are four main ways 3D printing tech impacts labor dynamics in construction. Management Workforce management is essential. Placing workers in positions best suited to their skill set and experience helps support labor productivity and project efficiency. 3D printing will affect supervision and management, influencing what positions decision-makers consider compatible. Skill Sets Workers will need to upskill or reskill soon to compensate for technological advancements. According to the Word Economic Forum, around 44% of employees’ skills will become irrelevant by 2027. Technology literacy is one of the fastest-growing core skills. Responsibilities An industrial 3D printer can build a foundation, walls and roof with minimal human intervention. Specialized machines can also weld, prototype scale models of blueprints or create custom tools. With all of that work automated, workers will need to find something new to do. Workflows A 3D printer can work much faster than humans because it doesn’t need to take breaks or go home for the night. Its automation capabilities could accelerate projects' most time-consuming phases, permanently changing traditional workflows. Does 3D Printing Tech Outperform Workers? An industrial 3D printer can make building processes more efficient and accurate. Since human error makes up 80% of all defects in housing construction, companies could lower material consumption by up to 40% if they used this tech instead of relying on people alone. 3D printing tech could walk circles around people, outperforming people in speed, efficiency and precision. It effectively forces workers to adapt or get replaced, shifting traditional labor roles toward more technologically advanced positions. If companies don’t need to rely on employees as much, they save a ton of money. In construction, labor costs account for 30% to 50% of total expenses, so they stand to save that much. This could greatly impact what they charge or what materials they use. Incorporating 3D printing tech into construction is only the beginning. Firms invested about $50 billion in architecture, engineering and construction tech from 2020 to 2022 — up 85% from 2017 to 2019 — for a reason. Digitalization will soon become an industry-wide standard. The Implications of This Industry-Wide Change The broader implications for the industry’s shifting labor dynamics are worth discussing. 1. Safety 3D printing tech could make worksites safer. For one, it produces fewer defects, leading to safer buildings. During construction, it can go into hard-to-reach places to keep workers out of harm’s way. Also, it eliminates or takes over dangerous tasks like lifting and welding. 2. Sustainability Using one formula instead of various materials shrinks companies’ need to ship, reducing their greenhouse gas emissions. Also, since using a 3D printer is cost-effective, leaders can afford to invest in sustainable building materials — which are 3% to 4% more expensive on average. 3. Training 3D printing tech likely won’t stay the same as time passes. To keep up with its inevitable technological evolutions — and the wave of integrations that’s likely to follow — ongoing employee training will be necessary. The Future of 3D Printing in Construction Workers may be wary of accepting a machine that could eventually replace them, so business leaders must help workers adapt to make implementation seamless. Raising awareness and conducting employee training programs is essential. As much as construction relies on heavy machinery and robotics, it needs human labor. This has been the status quo for decades — but that’s all about to change. Three-dimensional printing is drastically reshaping labor dynamics. How far will its reach extend? Construction’s Current Labor Dynamics Construction may be one of the most labor-intensive sectors in the world, but it isn’t getting much done. According to the Bureau of Labor Statistics, single-family residential construction productivity dropped by 0.8% from 2019 to 2023, even though hours worked were up by 0.9%. productivity dropped by 0.8% productivity dropped by 0.8% Highway, street and bridge construction fared even worse, with labor productivity down 3.6% despite hours worked increasing by 0.8% in the same period. While industrial and multifamily residential construction saw improvements, that’s still half the sector’s efficiency down. Construction is one of the most labor-intensive industries in the world. It employs 7% to 8.5% of the working population worldwide. Despite various technological advancements, it has remained entirely reliant on human labor — until now. 7% to 8.5% of the working population 7% to 8.5% of the working population Frankly, the industry is long overdue for change. That’s where 3D printing comes in. This tech operates mostly autonomously, only relying on humans for design, instruction and operation. If it becomes standard, it could permanently reshape labor dynamics. How 3D Printing Impacts Labor Dynamics There are four main ways 3D printing tech impacts labor dynamics in construction. Management Workforce management is essential. Placing workers in positions best suited to their skill set and experience helps support labor productivity and project efficiency. 3D printing will affect supervision and management, influencing what positions decision-makers consider compatible. helps support labor productivity helps support labor productivity Skill Sets Workers will need to upskill or reskill soon to compensate for technological advancements. According to the Word Economic Forum, around 44% of employees’ skills will become irrelevant by 2027. Technology literacy is one of the fastest-growing core skills. around 44% of employees’ skills around 44% of employees’ skills Responsibilities An industrial 3D printer can build a foundation, walls and roof with minimal human intervention. Specialized machines can also weld, prototype scale models of blueprints or create custom tools. With all of that work automated, workers will need to find something new to do. Workflows A 3D printer can work much faster than humans because it doesn’t need to take breaks or go home for the night. Its automation capabilities could accelerate projects' most time-consuming phases, permanently changing traditional workflows. Does 3D Printing Tech Outperform Workers? An industrial 3D printer can make building processes more efficient and accurate. Since human error makes up 80% of all defects in housing construction, companies could lower material consumption by up to 40% if they used this tech instead of relying on people alone. makes up 80% of all defects makes up 80% of all defects 3D printing tech could walk circles around people, outperforming people in speed, efficiency and precision. It effectively forces workers to adapt or get replaced, shifting traditional labor roles toward more technologically advanced positions. If companies don’t need to rely on employees as much, they save a ton of money. In construction, labor costs account for 30% to 50% of total expenses , so they stand to save that much. This could greatly impact what they charge or what materials they use. 30% to 50% of total expenses 30% to 50% of total expenses Incorporating 3D printing tech into construction is only the beginning. Firms invested about $50 billion in architecture, engineering and construction tech from 2020 to 2022 — up 85% from 2017 to 2019 — for a reason. Digitalization will soon become an industry-wide standard. invested about $50 billion invested about $50 billion The Implications of This Industry-Wide Change The broader implications for the industry’s shifting labor dynamics are worth discussing. 1. Safety 3D printing tech could make worksites safer. For one, it produces fewer defects, leading to safer buildings. During construction, it can go into hard-to-reach places to keep workers out of harm’s way. Also, it eliminates or takes over dangerous tasks like lifting and welding. 2. Sustainability Using one formula instead of various materials shrinks companies’ need to ship, reducing their greenhouse gas emissions. Also, since using a 3D printer is cost-effective, leaders can afford to invest in sustainable building materials — which are 3% to 4% more expensive on average. 3. Training 3D printing tech likely won’t stay the same as time passes. To keep up with its inevitable technological evolutions — and the wave of integrations that’s likely to follow — ongoing employee training will be necessary. The Future of 3D Printing in Construction Workers may be wary of accepting a machine that could eventually replace them, so business leaders must help workers adapt to make implementation seamless. Raising awareness and conducting employee training programs is essential.

How 3D Printing Is Reshaping Labor Dynamics in the Construction Industry

376 Stories To Learn About Google

How we automated SQL Server to Java migration and speeded up 4 times This article is dedicated to SQL Server modernization based on a project carried out by Ispirer for a large company operating in financial consulting. The customer harnessed the power of a SQL Server database to efficiently handle, process, access, and oversee their clients' financial information. The client aimed at migrating SQL Server to a cloud while optimizing system architecture and maintenance costs. Microsoft The Ispirer team offered to transfer business logic to Java because the database is used in OLTP mode. We will carefully analyze the subject and review the client's project, which involves converting SQL Server business rules to Java. Additionally, we will investigate the reasons behind companies opting to migrate SQL code to an application layer. This will involve a comprehensive examination of the entire process. To optimize the costs of cloud infrastructure, the client decided to migrate tables and data to PostgreSQL. Since we specialize in database and application migration, the customer turned to us with the following tasks: Moving 815000 LOC of business logic to the application layer in Java. Migrating 300 GB of data and 3000 tables from Microsoft SQL Server to PostgreSQL. Owing to the substantial scale of the project, the client endeavored to minimize migration expenses by implementing automation. To optimize the efficiency of the Ispirer Toolkit, we determined that its customization should be conducted in advance. This approach enabled us to deliver a tool to the client's team, with a T-SCL to Java conversion rate of approximately 90%. Now let’s dive deeper to the migration of tables and data. From SQL Server to PostgreSQL: migration of data and tables Let's consider the reasons why the customer chose to migrate from an on-premises SQL Server to the cloud. This transition includes a number of undeniable advantages: Cost Savings. One of the primary driving factors behind the migration from SQL Server to PostgreSQL in the cloud is cost savings. The client used to find it expensive to keep SQL Server databases on-site. This was due to the need for special equipment, software licenses, and skilled database administrators.
PostgreSQL, being an open-source database, offers a cost-effective alternative. Customers can save money by using the cloud. They only have to pay for what they use, instead of making big upfront payments. Additionally, they can spend less on operations. Scalability. Cloud computing can scale more easily than on-premises infrastructure to serve greater workloads and more users. For an on-prem system to scale with the needs of a business, organizations had to acquire and install physical servers, software licenses, storage, and network equipment to scale out business services in conventional IT settings.
On the cloud, most of these resources are available instantly within a few clicks and can be auto-scaled up and down depending on the resources needed. PostgreSQL in the cloud provides a high level of scalability, allowing our client to easily adjust resources based on demand. Security. Embracing cloud technology offers notable security advantages thanks to the advanced identity controls, access management, and authentication systems supplied by cloud providers. Often cloud providers have better security standards than in-house IT teams or local systems, making the data environment safer. Strong encryption in the cloud reduces the chance of data breaches. It includes layered security, good key management, and secure access controls, which help businesses control user access effectively. Furthermore, cloud providers rigorously oversee physical access, implementing measures such as anonymity, replication, and encryption to fortify data protection. By 2025, approximately are predicted to transition from physical data centers to cloud services. This shift is driven by the enhanced security benefits provided by the cloud. 80% of businesses Moving from SQL Server to PostgreSQL in the cloud requires careful planning and execution, with specific considerations in mind. Based on the client’s project, our team has highlighted the following steps for modernizing SQL Server: Schema and Data Transformation. Data should be transformed accurately to match PostgreSQL's requirements. This may involve handling nuances like date formats and character encoding. Constraints and Triggers. Understanding the distinctions in the usage of constraints and triggers in the two databases is crucial. It is necessary to make the necessary modifications accordingly. In addition, the functionality of triggers can be moved into the application. However, this task is far from simple, so it’s essential to weigh the pros and cons. Performance Optimization. Optimization of the migration process allows to minimize downtime and data transfer time. It’s important to utilize parallelization, optimize network bandwidth, and invest in powerful hardware for efficient migration Data Validation and Testing. Rigorous validation of the migrated data is required to guarantee data integrity and functionality. Extensive testing ensures that applications work seamlessly with the new PostgreSQL database. Security and Permissions. Security settings, user accounts, and permissions in PostgreSQL should be configured to match the original SQL Server setup, ensuring a seamless transition. Why move Business logic to Application Layer? In the past, our customers used stored procedures for their business logic, thinking it would improve performance. But let’s be honest, SQL language may not be the optimal choice for housing the business logic when compared to the application layer. In fact, SQL only queries or modifies the data in a database. Here many can throw rotten tomatoes at us, because SQL language is good at performing complex joins, filtering, and sorting in order to get exactly the data you need out of a query and nothing more. Then why change anything and bring the business logic to the application level? The question seems logical. Let's answer it in more detail. Below we have outlined 4 main reasons why you should seriously think about transferring business logic to the application. The client’s decision to move business logic to the application layer was driven by the following reasons: Scalability For scalability, storing business logic at the application level is the best option. Why? Because, in general, it’s substantially easier to scale your application server resources than it is to scale your database server resources.
This is almost universally acknowledged. For most web apps, adding more servers is usually easy when there's a lot of traffic to handle. However, the value of extra application servers diminishes unless your database can also scale to accommodate the augmented demand. Scaling a database server is considerably more challenging than simply adding application servers. Maintainability Storing business logic in a database can create maintainability challenges. Modifying stored procedures can disrupt many applications, limit extensibility, and make it challenging to follow the "Don't Repeat Yourself" (DRY) principle. SQL code that exceeds 100 lines often poses complexities and troubleshooting difficulties. Separating business logic into the application tier can facilitate new team members' entry and provides a more intuitive platform for refactoring. Ease of development SQL is a poor choice for encoding the business rules of your system. It's not flexible and we can't depend on it to represent complex models because it can't create proper abstractions. This limitation is the key reason to avoid using it for business logic. It's not about tooling or support, it's about SQL's inability to create a simple and expressive domain model, in contrast to object-oriented and functional design, which offer more opportunities. Reusability In software development, reusing code is an efficient way to save time and costs when adapting existing code for new tasks. Object-Oriented Programming (OOP) is a method that facilitates code recycling, making it suitable for various applications. However, SQL, commonly used in databases, offers limited flexibility for code reuse. Options include using "views" and "stored procedures," though the latter may lead to an abundance of parameters. To ensure the right choice for your project, exploring each method thoroughly is essential. Converting Transact-SQL to Java Converting Transact-SQL to Java involves various essential considerations. The process includes mapping SQL data types to their Java equivalents, ensuring accurate data representation. It also encompasses translating SQL queries into Java code, where Java relies on libraries like JDBC or Hibernate to handle database interactions. Moreover, certain ESQL features lack direct equivalents in Java, potentially giving the impression that automatic conversion is inefficient. During the customization phase of our project, we were able to create a number of conversion solutions that enhanced the automation rate. These solutions, initially believed to be impossible to automate, ultimately proved successful. Let’s delve into the details of some of them. Converting an INSERT statement in combination with a SCOPE_IDENTITY() to get the last identity value inserted into an identity column. Source: ALTER PROCEDURE example1
 AS
 BEGIN
     Declare @idBit int
     Declare @c int
     
     Insert Into tab (c) 
             Values (@c)
     
     Set @idBit = SCOPE_IDENTITY()
 End Target: @Service
 public class Example1 implements IExample1 {
     @Autowired
     private JdbcTemplate jdbcTemplate;
     private static final org.slf4j.Logger LOGGER = org.slf4j.LoggerFactory.getLogger(Example1.class);
     @Override
     public Integer spExample1() throws SQLException, Exception {
         Integer  mStatus = 0;
         KeyHolder keyHolder = new GeneratedKeyHolder();
         try {
             Integer idBit  = null;
             Integer c  = null;
             {
                 final Integer tmpC = c;
                 jdbcTemplate.update(connection-> {
                     PreparedStatement ps = connection.prepareStatement("Insert Into tab(c) \r\n" +
                     " Values(?)", new String[] { "" });
                     ps.setInt( 1, tmpC);
                     return ps;
                 }, keyHolder);
             }
             idBit = Tsqlutils.<Integer > strToNum(keyHolder.getKey().toString(), Integer.class);
             return mStatus;
         }
         catch (Exception e) {
             LOGGER.error(String.valueOf(e));
             mStatus = -1;
             return mStatus;
         }
     }
 } Conversion of procedure with multi Result Sets. Source: ALTER PROCEDURE [returnSeveralResultSet]
             @p1 int,
             @p2 varchar(50)
 AS
 Begin

     select cob_ft, lower(buzon) from tab1 
            where cob_id = @p1 and cob_ft = @p2
            
     select dep_ft, lower(fiton) from tab2
 END Target: @Service
 public class Returnseveralresultset implements IReturnseveralresultset {
     @Autowired
     private JdbcTemplate jdbcTemplate;
     private static final org.slf4j.Logger LOGGER = org.slf4j.LoggerFactory.getLogger(Returnseveralresultset.class);
     private Integer errorCode = 0;
     private String sqlState = "";
     @Override
     public Map<String, Object> spReturnseveralresultset(Integer p1,
             String p2) throws Exception {
         Integer  mStatus = 0;
         Map<String, Object> outData  = new HashMap<>();
         List<SqlRowSet> outRsList = new ArrayList<>();
         SqlRowSet rowSet;

         try {
             rowSet = jdbcTemplate.queryForRowSet("select cob_ft, lower(buzon) from tab1  \r\n" +
                                                  " where cob_id = ? and cob_ft = ?", p1, p2);
             outRsList.add(rowSet);
             rowSet = jdbcTemplate.queryForRowSet("select dep_ft, lower(fiton) from tab2");
             outRsList.add(rowSet);
             return outData;
         }
         catch (Exception e) {
             LOGGER.error(String.valueOf(e));
             mStatus = -1;
             return outData;
         }
         finally {
             outData.put("status", mStatus);
             outData.put("rsList", outRsList);
         }
     }
 } Conversion of DATEDIFF method. Since Java has no direct equivalents, the Ispirer team developed an equivalent to this method that casts String to Timestamp without an explicitly specified format. It makes the code result uncluttered and easier to read. The example below demonstrates how it is used. Source: create procedure datediffFn
 as
     declare @var1 int
     set @var1 = DATEDIFF(dd, '1999-01-01', '2000-02-01')
     set @var1 = DATEDIFF(mm, getdate(), '2000-02-01')
     set @var1 = DATEDIFF(week, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); Target: public Integer spDatedifffn() throws Exception {
         Integer  mStatus = 0;

         try {
             Integer var1  = null;
             var1 = Tsqlutils.datediff("dd", Tsqlutils.toTimestamp("1999-01-01"), Tsqlutils.toTimestamp("2000-02-01"));
             var1 = Tsqlutils.datediff("mm", new Timestamp(new java.util.Date().getTime()), Tsqlutils.toTimestamp("2000-02-01"));
             var1 = Tsqlutils.datediff("week", Tsqlutils.toTimestamp("2005-12-31 23:59:59.9999999"), Tsqlutils.toTimestamp("2006-01-01 00:00:00.0000000"));
             return mStatus;
         }
         catch (Exception e) {
             LOGGER.error(String.valueOf(e));
             mStatus = -1;
             return mStatus;
         }
     } Conversion of sp_send_dbmail method which sends an e-mail message to the specified recipients. For this purpose, a class called MailService was developed. This method makes it possible to send emails with detailed specifications, including recipients (TO), recipients of a copy (CC), recipients in a blind carbon copy (BCC), the subject of the letter, the main text, attachments, and more. To keep the main code uncluttered, our team placed the method in a separate class. Source: create PROCEDURE spSendDbmail  
 AS  
 BEGIN    
     
     EXEC msdb.dbo.sp_send_dbmail  
         @profile_name = 'New DB Ispirer Profile',  
         @recipients = 'user1@ispirer.com',  
         @body = '<h1>This is actual message embedded in HTML tags</h1>',  
         @subject = 'Automated Success Message' ,
         @file_attachments = 'C:\Temp\Attached.txt',
         @body_format='HTML', 
         @copy_recipients = 'user2@ispirer.com',
         @blind_copy_recipients = 'user3@ispirer.com'; 
 END Target: import java.util.*;
 import com.ispirer.mssql.mail.MailService;
 public class Spsenddbmail {
     private static final org.slf4j.Logger LOGGER = org.slf4j.LoggerFactory.getLogger(Spsenddbmail.class);
     public Integer spSpsenddbmail() throws Exception {
         Integer  mStatus = 0;

         try {
             MailService.send("New DB Ispirer Profile", "Automated Success Message", "<h1>This is actual message embedded in HTML tags</h1>", "user1@ispirer.com", "user2@ispirer.com", "user3@ispirer.com", "C:\\Temp\\Attached.txt", "HTML");
             return mStatus;
         }
         catch (Exception e) {
             LOGGER.error(String.valueOf(e));
             mStatus = -1;
             return mStatus;
         }
     }
 } The Ispirer team has developed an XMLUtils class for converting xml Data type and its methods, which are used to get any information from XML data stored in an XML variable. An example implementation of the method: Source: create procedure workWithXml
 AS
 begin
     declare @result bit, @myDoc XML, @myStr varchar(1000), @ProdID INT  
     
     SET @myDoc = '<Root>  
     <ProductDescription ProductID="1" ProductName="Road Bike">  
     <Features>  
       <Warranty>1 year parts and labor</Warranty>  
       <Maintenance>3 year parts and labor extended maintenance is available</Maintenance>  
     </Features>  
     </ProductDescription>  
     </Root>'  
       
     SET @result = @myDoc.exist('(/Root/ProductDescription/@ProductID)[1]') 

     SET @myStr = cast(@myDoc.query('/Root/ProductDescription/Features') as varchar(max))
     
     SET @ProdID =  @myDoc.value('(/Root/ProductDescription/@ProductID)[1]', 'int' )  

 end; Target: import java.util.*;
 import com.ispirer.mssql.xml.XMLUtils;
 public class Workwithxml {
     private static final org.slf4j.Logger LOGGER = org.slf4j.LoggerFactory.getLogger(Workwithxml.class);
     public Integer spWorkwithxml() throws Exception {
         Integer  mStatus = 0;

         try {
             Boolean result  = null;
             String myDoc  = null;
             String myStr  = null;
             Integer prodID  = null;
             myDoc = "<Root>   " +
                     "<ProductDescription ProductID=\"1\" ProductName=\"Road Bike\">   " +
                     "<Features>   " +
                     "<Warranty>1 year parts and labor</Warranty>   " +
                     "<Maintenance>3 year parts and labor extended maintenance is available</Maintenance>   " +
                     "</Features>   " +
                     "</ProductDescription>   " +
                     " </Root>";
             result = XMLUtils.exist(myDoc, "(/Root/ProductDescription/@ProductID)[1]");
             myStr = XMLUtils.query(myDoc, "/Root/ProductDescription/Features");
             prodID =  XMLUtils.<Integer > value(myDoc, "(/Root/ProductDescription/@ProductID)[1]", Integer.class);
             return mStatus;
         }
         catch (Exception e) {
             LOGGER.error(String.valueOf(e));
             mStatus = -1;
             return mStatus;
         }
     }
 } Thanks to our customization efforts, our team has successfully developed a range of techniques to automate the transition from T-SQL to Java. This has significantly slashed the overall migration time for the entire project, allowing us to accelerate migration 4 times compared to potential manual migration. Our Toolkit customization not only expedited the transition but also enhanced the project's overall efficiency, showcasing the valuable impact of our customization initiatives. The methods specified in the examples are provided to the client along with the conversion results. Conclusion In conclusion, transitioning business logic from Transact-SQL to Java is a multifaceted process that requires a comprehensive understanding of both languages and their distinct features. In this article we thoroughly explored the migration of business logic to an app layer, and provided valuable insights for those who are planning such a transition. The case of our client proves that such modernization projects can be automated which significantly saves time and effort during migration. Our client's project serves as a compelling testament to the remarkable potential of automation. It demonstrates that there are modernization facets where automation can successfully streamline processes that may initially appear beyond its capabilities. Ultimately, embracing the migration from is a strategic move for organizations seeking greater flexibility, cross-platform compatibility, and scalability. While it presents its challenges, the benefits in terms of portability, performance, and adaptability to modern software architectures make this transition a worthwhile endeavor for those looking to modernize their database systems and applications. Transact-SQL to Java

Business Logic Migration Made Faster Than Your Coffee Brews

বিজনেস লজিক মাইগ্রেশন আপনার কফি ব্রিজের চেয়ে দ্রুত তৈরি হয়েছে

Die Migration der Geschäftslogik geht schneller als Ihr Kaffee

La migración de la lógica empresarial es más rápida que las preparaciones de café

Migration de logique métier plus rapide que vos préparations de café

बिजनेस लॉजिक माइग्रेशन आपके कॉफ़ी ब्रूज़ की तुलना में तेज़ बना

ビジネス ロジックの移行はコーヒーを淹れるよりも早く完了

커피를 끓이는 것보다 더 빠른 비즈니스 로직 마이그레이션

Migração da lógica de negócios mais rápida do que sua preparação de café

Миграция бизнес-логики выполняется быстрее, чем заваривается кофе

İş Mantığı Geçişi Kahve Demlemekten Daha Hızlı

Quá trình di chuyển logic kinh doanh được thực hiện nhanh hơn việc pha cà phê của bạn

业务逻辑迁移速度比咖啡冲泡还要快

327 Stories To Learn About Leadership

278 Stories To Learn About Covid 19

299 Stories To Learn About Seo

121 Stories To Learn About Management And Leadership

Modern Central Processing Units (CPUs) contain multiple cores which allow for several threads to be run in parallel and more than one task to be performed at a time. This enables your iPhone app to, for instance, download a large file in the background while the user interface remains responsive. Apple provides two methods for multitasking in iOS development, Grand Central Dispatch (GCD) and NSOperation. In this article, we will look at GCD. If you need a refresher on the basics of concurrency in iOS development, check out . this article GCD was introduced in iOS 4 and offers the developer flexibility when using concurrency in their application. The main idea behind GCD is to move thread management closer to the It abstracts threads away from the developer, who will not need to consider so many details. In essence, GCD decides which thread should be used to execute any given task. operating system. Content Overview Dispatch Queues Quality of Service (QOS) Background Utility User-Initiated User-interactive Order and Manner of Dispatch Synchronous vs Asynchronous Serial vs Concurrent Serial Queues Concurrent Queues Global Queues Dispatch Methods Conclusion Dispatch Queues A term that is frequently used when discussing GCD is . A dispatch queue is an abstraction layer on top of a queue that contains tasks to be executed following the FIFO (first in, first out) algorithm. dispatch queue GCD manages a collection of dispatch queues. The work items submitted to these dispatch queues are executed on a pool of threads. There is a dispatch queue that represents the application’s main thread (also known as the UI thread) and multiple dispatch queues which represent the many background threads. Quality Of Service (QOS) A quality-of-service (QOS) class categorizes the work items which are performed on a dispatch queue. With this parameter, the priority of a given task is specified. There are four QOS classes that may be assigned to a queue. Background These are tasks that can take minutes or hours to complete such as loading or processing large amounts of data. They are not time-critical and the user needs to be able to do other things while they are happening. Such tasks are mapped to a low-priority queue. Utility These tasks take seconds or minutes and should be completed immediately. An example of a utility task would be one with a loading bar, such as a download. User-initiated These are tasks initiated by the user which should be executed right away, such as opening a document. They will be mapped to a high-priority queue and should only take a few seconds or less. User-interactive These are UI tasks that need to be finished immediately to ensure that the user is able to continue with the next interaction. They are mapped to the queue with the highest priority and run on the main thread. Order and manner of dispatch When using queues, the order and manner in which tasks are dispatched need to be chosen. GCD queues can be serial or concurrent and pushing tasks to them can happen synchronously or asynchronously. Synchronous vs asynchronous When a work item is scheduled synchronously, the execution of code that is happening on the current thread is paused until the item’s execution is completed. It is important not to execute a work item synchronously on the main queue as this results in a deadlock. When it is scheduled asynchronously, the code on the current thread continues to be executed while the work item is scheduled to run on another thread. Serial vs concurrent In a serial queue, tasks are executed one after the other according to the FIFO algorithm. The serial queue just needs one thread since only one task is running at a time. A concurrent queue creates as many threads as it has tasks dispatched into it. The developer does not control the creation of the threads. Serial Queues An example of a serial queue can be found below. func mySerialQueue() {
  let serialQueue = DispatchQueue(label: "com.kraken.serial")
  serialQueue.async {
    sleep(1)
    print("Task 1")
  }
  serialQueue.async {
    print("Task 2")
  }
} Despite the “sleep” instruction within the first task, the output will be: Task1
Task2 This is because the tasks are executed serially in the order in which they were added to the queue. Serial execution is not ideal since one task has to wait for the other. Even if the task that is first in the queue takes much longer than the task behind it, the first task will be given priority. Think of it like two people waiting in line at the grocery store with the first person making a large purchase for the whole week while the person behind them is only buying one small item. In this case, it makes sense to let the person with the small item pass first so that they can go on with their day without any unnecessary delay. Concurrent Queues Let us look more closely at how multiple tasks, or work items, can be run at the same time by utilizing a concurrent queue. Using the .concurrent flag creates a queue that allows many tasks to be performed simultaneously. One task does not have to wait for another to finish. func concurrentQueues(){
    let myQueue = DispatchQueue(label: "com.multithreading.concurr", qos: .utility, attributes: .concurrent)
    myQueue.async {
        for i in 0..<10 {
            print("1")
        }
    }
    myQueue.async {
        for j in 0..<10 {
            print("2")
        }
    }
} In this case, the output would alternate between “1” and “2” as the threads belonging to each of the two tasks are getting switched out. With concurrent execution, it is important not to call methods that block the current thread. If a task that blocks a thread is scheduled by a concurrent dispatch queue, it will cause the system to create new threads to run other concurrent tasks in the queue. As a result, the system could run out of threads. Apps can also use up too many threads if too many private concurrent dispatch queues are created. Each dispatch queue consumes thread resources. Instead of creating private concurrent queues, tasks can be submitted to one of the global concurrent dispatch queues. Global Queues GCD creates a set of dispatch queues also known as global queues. They can be used freely like custom queues. let myGlobalQueue = DispatchQueue.global() The QOS class can be set by the developer. If this parameter is not set, the default case is used. let myGlobalQueue = DispatchQueue.global(qos: .userInitiated) Accessing the main queue to perform tasks such as updating the UI can be done by calling the main queue and specifying if a synchronous or asynchronous call should be made. DispatchQueue.main.async {} Dispatch Methods Let us look at some of the different functions GCD provides to dispatch tasks. Dispatch Group A dispatch group is a group of tasks that is monitored as one unit. This way, collections of tasks can be aggregated. Multiple work items are attached to a group and scheduled for asynchronous execution. This way, multiple processes can be started but only one event is needed which occurs when all tasks have been completed. For instance, a dispatch group can be useful when multiple calls to APIs need to be made on a background thread before the UI can be updated on the main thread. func myTask1(dispatchGroup:DispatchGroup){
    DispatchQueue.global().async {
        print("Task 1 finished")
        dispatchGroup.leave()
    }
}

func myTask2(dispatchGroup:DispatchGroup){
    DispatchQueue.global().async {
        print("Task 2 finished")
        dispatchGroup.leave()
    }
}
 
func myDispatchGroup(){
    let dispatchGroup = DispatchGroup()
    dispatchGroup.enter()
    myTask1(dispatchGroup: dispatchGroup)
    dispatchGroup.enter()
    myTask2(dispatchGroup: dispatchGroup)
 
    dispatchGroup.notify(queue: .main) {
        print("All tasks finished.")
    }
} In the given example, the two tasks are grouped together and the main queue is only notified once they have both been completed. Dispatch Work Item A dispatch work item encapsulates a block of code and provides the flexibility to cancel the given task. Imagine that you are using the search function in an app. With every typed letter, a new search call is made and the previous one is canceled. func search(_ searchBar: UISearchBar, textChanged searchText: String) {
    workItem?.cancel()
 
    let searchWorkItem = DispatchWorkItem {
        print("Run search call with text: \(searchText)")
    }
 
    workItem = searchWorkItem
    DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(100), execute: searchWorkItem)
} Dispatch Semaphore The dispatch semaphore uses a counting semaphore to control access to a resource that can be accessed by multiple threads. This is a way to implement the critical section, where a shared resource is accessed by a process that would not operate correctly if the resource was accessed concurrently by another process. let mySemaphore = DispatchSemaphore(value: 1)
mySemaphore.wait()
task { (result) in
    mySemaphore.signal()
} wait() is called to access a shared resource. signal() is called when a shared resource should be released. The value contained in DispatchSemaphore describes the number of tasks running concurrently. Dispatch Barrier Another way to implement the critical section is a dispatch barrier which ensures that no other task is being processed while the given one is executed. func myDispatchBarrier(){
    let myConcQueue = DispatchQueue(label: "com.kraken.barrier", attributes: .concurrent)
 
    for i in 1…3 {
        myConcQueue.async() {
            print("Asynchronous Task")
        }
    }
 
    for j in 1…3 {
        myConcQueue.async(flags: .barrier) {
            print("Barrier")
        }
    }
} The three “Barrier” printouts in the output will not be interrupted by an “Asynchronous Task” printout at any point. Async after This method can be utilized to delay the execution of a task. GCD enables the developer to set the amount of time after which the task should be run. let time = 2.0
DispatchQueue.main.asyncAfter(deadline: .now() + time){
    print("Delayed task")
} Conclusion With GCD, has provided a multithreading model that is efficient and minimizes the risk of issues related to concurrency such as deadlocks. Apple Expensive tasks are performed in the background, leaving the main thread unaffected and thus improving the responsiveness of the application. As thread management is taken on by the operating system, the developer does not have to implement it by hand and can rely on GCD to match the running applications to the available system resources in a balanced manner. Also published here. The lead image for this article was generated by HackerNoon's AI Image Generator via the prompt "ios development”.

Grand Central Dispatch (GCD) in iOS: The Developer's Guide

197 Stories To Learn About Communication

Big Tech Companies Have Your Health Info Thanks to Telehealth Startups

Stories, News & Mentions about WORKKIT

Workkit’s Stories on HackerNoon