Cybersecurity isn’t just for tech experts — it’s a responsibility that affects every person, organization, and even entire nations.

Cybersecurity: The New Front Line and Why Everyone Should Care | by Christi Lee | Dec, 2024 | Medium

Here's the latest from the frontline in Ukraine as Russia's grinding invasion nears its second year.

Russian forces reportedly advance in Ukraine's Avdiivka | Euronews

Front

front

Next.js v15 — What’s new under the hood

Minder AI Structured Interactive Language - A New Frontier Open Standard

The entertainment industry is descending upon Las Vegas this week and next for the annual LDI Show. The industry continually seeks cutting-edge solutions to create immersive and unforgettable experiences and Elation just shared two launches before the show floor opened—the PARAGON Series and the REBEL Profile™. But this isn’t just about new products; it’s about rethinking what lighting technology can do, blending innovation, creativity, and practicality to set new standards for the future. For decades, the evolution of lighting has mirrored the progress of technology itself, transforming not only what is possible on stage but also behind the scenes. Elation’s announcements at LDI 2024 exemplify this intersection, with products that cater to the modern challenges of entertainment professionals while pushing the boundaries of creative expression. The PARAGON Series, featuring Elation’s proprietary TruTone™ technology, represents a leap forward in adaptability and precision. TruTone’s ability to seamlessly adjust CRI from 70 to 93 allows for unparalleled control over color fidelity without altering color temperature. For lighting designers, this means skin tones, costumes, and scenery can be transformed with vibrant depth and accuracy, empowering them to create more visually dynamic environments with fewer fixtures. “The PARAGON Series represents far more than a mere incremental advancement in design technology—it represents a leap forward in intelligent, precision lighting for the entertainment industry, and has been designed to satisfy the highest creative standards,” said Nick Saiki, Product Application and Customer Experience Specialist, Elation. “With TruTone technology, designers are no longer constrained by compromises between artistic vision and practical limitations, while its IP54 weatherproof rating means its wealth of design options can also be used to enhance temporary outdoor events, elevating its versatility for multi-event use.” On the other hand, the REBEL Profile™ is Elation’s answer to the growing demand for compact, rugged fixtures that deliver top-tier performance. Its 500W LED engine offers intense beams and sharp projections, while an IP65 rating ensures durability in both indoor and outdoor environments. This combination of versatility and resilience makes the REBEL Profile an ideal solution for the fast-paced demands of modern productions. Why Lighting Innovation Matters Lighting isn’t just a functional element—it’s an integral part of storytelling. Whether in a concert, theatrical production, or live event, lighting directs focus, evokes emotion and creates atmosphere. Yet, the tools lighting professionals rely on often lag behind the creative aspirations of their users. Elation’s offerings aim to bridge that gap by providing: Enhanced Efficiency: The multi-role functionality of the PARAGON Series reduces the number of fixtures needed, streamlining setups and cutting costs.
Sustainability: Energy-efficient engines in both product lines address growing demands for greener solutions in live entertainment.
Future-Proof Design: Features like TruTone and high-output LED engines ensure these fixtures remain relevant as industry needs evolve. Looking Back to Look Forward: The Evolution of Stage Lighting At LDI 2024, Elation is also debuting The Evolution of Stage Lighting infographic, a visual journey through the milestones that have shaped the industry. From the days of incandescent lamps to the rise of LED technology, this retrospective highlights how far lighting has come—and how innovations like PARAGON and REBEL are charting the course for the future. By highlighting the history and future of stage lighting, Elation is positioning itself not just as a product provider, but as a thought leader driving the industry forward. This year, the company has promoted it’s booth heavily which is designed as a retro-futuristic spaceport lounge, serves as a metaphor for the company’s vision. It’s a space where past and future collide, inviting attendees to explore the possibilities of what’s next. With live product demonstrations, an hourly light show, and immersive displays, the booth embodies the campaign theme, “Experience Tomorrow.” “The goal isn’t to just showcase products at LDI, but to guide visitors through a journey into lighting’s next frontier,” said Saiki. “We’re inviting lighting professionals to ‘Experience Tomorrow’ in an immersive spaceport-themed setting that highlights our visionary lighting solutions. We want professionals to walk away inspired by what’s possible, armed with the tools to make the extraordinary happen.” Lighting the Path Forward Elation’s offerings at LDI 2024 are more than just new fixtures—they are a bold statement about the direction of entertainment technology. By addressing real-world challenges with solutions that don’t compromise creativity, the company is setting a new benchmark for the industry. The  future of lighting isn’t just about brighter beams or sharper projections—it’s about empowering designers to tell better stories, more efficiently, and with greater impact. The entertainment industry is descending upon Las Vegas this week and next for the annual LDI Show. The industry continually seeks cutting-edge solutions to create immersive and unforgettable experiences and Elation just shared two launches before the show floor opened—the PARAGON Series and the REBEL Profile™ . But this isn’t just about new products; it’s about rethinking what lighting technology can do, blending innovation, creativity, and practicality to set new standards for the future. Elation Elation PARAGON Series REBEL Profile™ For decades, the evolution of lighting has mirrored the progress of technology itself, transforming not only what is possible on stage but also behind the scenes. Elation’s announcements at LDI 2024 exemplify this intersection, with products that cater to the modern challenges of entertainment professionals while pushing the boundaries of creative expression. The PARAGON Series, featuring Elation’s proprietary TruTone™ technology, represents a leap forward in adaptability and precision. TruTone’s ability to seamlessly adjust CRI from 70 to 93 allows for unparalleled control over color fidelity without altering color temperature. For lighting designers, this means skin tones, costumes, and scenery can be transformed with vibrant depth and accuracy, empowering them to create more visually dynamic environments with fewer fixtures. “The PARAGON Series represents far more than a mere incremental advancement in design technology—it represents a leap forward in intelligent, precision lighting for the entertainment industry, and has been designed to satisfy the highest creative standards,” said Nick Saiki, Product Application and Customer Experience Specialist, Elation. “The PARAGON Series represents far more than a mere incremental advancement in design technology—it represents a leap forward in intelligent, precision lighting for the entertainment industry, and has been designed to satisfy the highest creative standards,” said Nick Saiki, Product Application and Customer Experience Specialist, Elation. “With TruTone technology, designers are no longer constrained by compromises between artistic vision and practical limitations, while its IP54 weatherproof rating means its wealth of design options can also be used to enhance temporary outdoor events, elevating its versatility for multi-event use.” On the other hand, the REBEL Profile™ is Elation’s answer to the growing demand for compact, rugged fixtures that deliver top-tier performance. Its 500W LED engine offers intense beams and sharp projections, while an IP65 rating ensures durability in both indoor and outdoor environments. This combination of versatility and resilience makes the REBEL Profile an ideal solution for the fast-paced demands of modern productions. Why Lighting Innovation Matters Lighting isn’t just a functional element—it’s an integral part of storytelling. Whether in a concert, theatrical production, or live event, lighting directs focus, evokes emotion and creates atmosphere. Yet, the tools lighting professionals rely on often lag behind the creative aspirations of their users. Elation’s offerings aim to bridge that gap by providing: Enhanced Efficiency: The multi-role functionality of the PARAGON Series reduces the number of fixtures needed, streamlining setups and cutting costs. Sustainability: Energy-efficient engines in both product lines address growing demands for greener solutions in live entertainment. Future-Proof Design: Features like TruTone and high-output LED engines ensure these fixtures remain relevant as industry needs evolve. Enhanced Efficiency: The multi-role functionality of the PARAGON Series reduces the number of fixtures needed, streamlining setups and cutting costs. Sustainability: Energy-efficient engines in both product lines address growing demands for greener solutions in live entertainment. Future-Proof Design: Features like TruTone and high-output LED engines ensure these fixtures remain relevant as industry needs evolve. Looking Back to Look Forward: The Evolution of Stage Lighting At LDI 2024, Elation is also debuting The Evolution of Stage Lighting infographic , a visual journey through the milestones that have shaped the industry. From the days of incandescent lamps to the rise of LED technology, this retrospective highlights how far lighting has come—and how innovations like PARAGON and REBEL are charting the course for the future. By highlighting the history and future of stage lighting, Elation is positioning itself not just as a product provider, but as a thought leader driving the industry forward. The Evolution of Stage Lighting The Evolution of Stage Lighting The Evolution of Stage Lighting infographic infographic This year, the company has promoted it’s booth heavily which is designed as a retro-futuristic spaceport lounge, serves as a metaphor for the company’s vision. It’s a space where past and future collide, inviting attendees to explore the possibilities of what’s next. With live product demonstrations, an hourly light show, and immersive displays, the booth embodies the campaign theme, “Experience Tomorrow.” “The goal isn’t to just showcase products at LDI, but to guide visitors through a journey into lighting’s next frontier,” said Saiki. “We’re inviting lighting professionals to ‘Experience Tomorrow’ in an immersive spaceport-themed setting that highlights our visionary lighting solutions. We want professionals to walk away inspired by what’s possible, armed with the tools to make the extraordinary happen.” “The goal isn’t to just showcase products at LDI, but to guide visitors through a journey into lighting’s next frontier,” said Saiki. “We’re inviting lighting professionals to ‘Experience Tomorrow’ in an immersive spaceport-themed setting that highlights our visionary lighting solutions. We want professionals to walk away inspired by what’s possible, armed with the tools to make the extraordinary happen.” Lighting the Path Forward Elation’s offerings at LDI 2024 are more than just new fixtures—they are a bold statement about the direction of entertainment technology. By addressing real-world challenges with solutions that don’t compromise creativity, the company is setting a new benchmark for the industry. The  future of lighting isn’t just about brighter beams or sharper projections—it’s about empowering designers to tell better stories, more efficiently, and with greater impact.

Lighting’s Next Frontier: How Elation is Merging Innovation and Reliability at LDI 2024

Front-End Deployment Insights: Experiences and Metric Evaluations of Leading Cloud Platforms

In my previous post, I talked about why Console.log() isn’t the most effective debugging tool. In this installment, we will do a bit of an about-face and discuss the ways in which Console.log() is fantastic. Let’s break down some essential concepts and practices that can make your debugging life much easier and more productive. https://youtu.be/Qi7S98HNhYY?embedable=true As a side note, if you like the content of this and the other posts in this series, check out my Debugging book that covers this subject. If you have friends who are learning to code, I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while, check out my Java 8 to 21 book. Understanding Front-End Logging vs. Back-End Logging Front-end logging differs significantly from back-end logging, and understanding this distinction is crucial. Unlike back-end systems, where persistent logs are vital for monitoring and debugging, the fluid nature of front-end development introduces different challenges. When debugging backends, I’d often go for tracepoints which are far superior in that setting. However, the front-end with its constant need to refresh, reload, contexts switch, etc. is a very different beast. In the front end, relying heavily on elaborate logging mechanisms can become cumbersome. While tracepoints remain superior to basic print statements, the continuous testing and browser reloading in front-end workflows lessen their advantage. Moreover, features like logging to a file or structured ingestion are rarely useful in the browser, diminishing the need for a comprehensive logging framework. However, using a logger is still considered best practice over the typical Console.log for long-term logging… For short-term logging, Console.log has some tricks up its sleeve. Leveraging Console Log Levels One of the hidden gems of the browser console is its support for log levels, which is a significant step up from rudimentary print statements. The console provides five levels: • log: Standard logging • debug: Same as log but used for debugging purposes • info: Informative messages, often rendered like log/debug • warn: Warnings that might need attention • error: Errors that have occurred While log and debug can be indistinguishable, these levels allow for a more organized and filtered debugging experience. Browsers enable filtering the output based on these levels, mirroring the capabilities of server-side logging systems and allowing you to focus on relevant messages. Customizing Console Output With CSS Front-end development allows for creative solutions, and logging is no exception. Using CSS styles in the console can make logs more visually distinct. By utilizing %c in a console message, you can apply custom CSS: console.customLog = function(msg) {
    console.log("%c" + msg,"color:black;background:pink;font-family:system-ui;font-size:4rem;-webkit-text-stroke: 1px black;font-weight:bold")
}
console.customLog("Dazzle") This approach is helpful when you need to make specific logs stand out or organize output visually. You can use multiple %c substitutions to apply various styles to different parts of a log message. Stack Tracing With console.trace() The console.trace() method can print a stack trace at a particular location, which can sometimes be helpful for understanding the flow of your code. However, due to JavaScript’s asynchronous behavior, stack traces aren’t always as straightforward as in back-end debugging. Still, in specific scenarios, such as synchronous code segments or event handling, it can be quite valuable. Assertions for Design-by-Contract Assertions in front-end code allow developers to enforce expectations and promote a “fail-fast” mentality. Using Console.assert(), you can test conditions: console.assert(x > 0, 'x must be greater than zero'); In the browser, a failed assertion appears as an error, similar to a console.error. An added benefit is that assertions can be stripped from production builds, removing any performance impact. This makes assertions a great tool for enforcing design contracts during development without compromising production efficiency. Copying Objects to the Clipboard Debugging often involves inspecting objects, and the copy(object) method allows you to copy an object’s content to the clipboard for external use. This feature is useful when you need to transfer data or analyze it outside the browser. Inspecting With console.dir() and dirxml() The console.dir() method provides a more detailed view of objects, showing their properties as you’d see in a debugger. This is particularly helpful for inspecting DOM elements or exploring API responses. Meanwhile, console.dirxml() allows you to view objects as XML, which can be useful when debugging HTML structures. Counting Function Calls Keeping track of how often a function is called or a code block is executed can be crucial. The console.count() method tracks the number of times it’s invoked, helping you verify that functions are called as expected: function myFunction() {
    console.count('myFunction called');
} You can reset the counter using console.countReset(). This simple tool can help you catch performance issues or confirm the correct execution flow. Organizing Logs With Groups To prevent log clutter, use console groups to organize related messages. console.group() starts a collapsible log section, and console.groupEnd() closes it: console.group('My Group');
console.log('Message 1');
console.log('Message 2');
console.groupEnd(); Grouping makes it easier to navigate complex logs and keeps your console clean. Chrome-Specific Debugging Features Monitoring Functions: Chrome’s monitor() method logs every call to a function, showing the arguments and enabling a method-tracing experience. Monitoring Events: Using monitorEvents(), you can log events on an element. This is useful for debugging UI interactions. For example, monitorEvents(window, 'mouseout') logs only mouseout events. Querying Object Instances: queryObjects(Constructor) lists all objects created with a specific constructor, giving you insights into memory usage and object instantiation. Final Word Front-end debugging tools have come a long way. These tools provide a rich set of features that go far beyond simple console.log() statements. From log levels and CSS styling to assertions and event monitoring, mastering these techniques can transform your debugging workflow. If you read this post as part of my series, you will notice a big change in my attitude toward debugging when we reached the front end. Front-end debugging is very different when compared to back-end debugging. When debugging the backend, I’m vehemently against code changes for debugging (e.g. println debugging), but on the front end, this can be a reasonable hack. The change in environment justifies it. The short lifecycle, the single-user use case, and the risk is smaller. While there are many transferrable skills we pick up while debugging, it’s important to remain flexible in our attitude. Next time, we will discuss networking and storage debugging on the front end. In my previous post, I talked about why Console.log() isn’t the most effective debugging tool. In this installment, we will do a bit of an about-face and discuss the ways in which Console.log() is fantastic. Let’s break down some essential concepts and practices that can make your debugging life much easier and more productive. Console.log() Console.log() https://youtu.be/Qi7S98HNhYY?embedable=true https://youtu.be/Qi7S98HNhYY?embedable=true As a side note, if you like the content of this and the other posts in this series, check out my Debugging book that covers t his subject. If you have friends who are learning to code, I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while, check out my Java 8 to 21 book . Debugging book t Java Basics book. Java 8 to 21 book . Understanding Front-End Logging vs. Back-End Logging Understanding Front-End Logging vs. Back-End Logging Front-end logging differs significantly from back-end logging, and understanding this distinction is crucial. Unlike back-end systems, where persistent logs are vital for monitoring and debugging, the fluid nature of front-end development introduces different challenges. When debugging backends, I’d often go for tracepoints which are far superior in that setting. However, the front-end with its constant need to refresh, reload, contexts switch, etc. is a very different beast. In the front end, relying heavily on elaborate logging mechanisms can become cumbersome. While tracepoints remain superior to basic print statements, the continuous testing and browser reloading in front-end workflows lessen their advantage. Moreover, features like logging to a file or structured ingestion are rarely useful in the browser, diminishing the need for a comprehensive logging framework. However, using a logger is still considered best practice over the typical Console.log for long-term logging… For short-term logging, Console.log has some tricks up its sleeve. Console.log Console.log Leveraging Console Log Levels Leveraging Console Log Levels One of the hidden gems of the browser console is its support for log levels, which is a significant step up from rudimentary print statements. The console provides five levels: • log : Standard logging log • debug : Same as log but used for debugging purposes debug • info : Informative messages, often rendered like log/debug info • warn : Warnings that might need attention warn • error : Errors that have occurred error While log and debug can be indistinguishable, these levels allow for a more organized and filtered debugging experience. Browsers enable filtering the output based on these levels, mirroring the capabilities of server-side logging systems and allowing you to focus on relevant messages. Customizing Console Output With CSS Customizing Console Output With CSS Front-end development allows for creative solutions, and logging is no exception. Using CSS styles in the console can make logs more visually distinct. By utilizing %c in a console message, you can apply custom CSS: %c console.customLog = function(msg) {
    console.log("%c" + msg,"color:black;background:pink;font-family:system-ui;font-size:4rem;-webkit-text-stroke: 1px black;font-weight:bold")
}
console.customLog("Dazzle") console.customLog = function(msg) {
    console.log("%c" + msg,"color:black;background:pink;font-family:system-ui;font-size:4rem;-webkit-text-stroke: 1px black;font-weight:bold")
}
console.customLog("Dazzle") This approach is helpful when you need to make specific logs stand out or organize output visually. You can use multiple %c substitutions to apply various styles to different parts of a log message. %c Stack Tracing With console.trace() Stack Tracing With console.trace() The console.trace() method can print a stack trace at a particular location, which can sometimes be helpful for understanding the flow of your code. However, due to JavaScript’s asynchronous behavior, stack traces aren’t always as straightforward as in back-end debugging. Still, in specific scenarios, such as synchronous code segments or event handling, it can be quite valuable. console.trace() Assertions for Design-by-Contract Assertions for Design-by-Contract Assertions in front-end code allow developers to enforce expectations and promote a “fail-fast” mentality. Using Console.assert() , you can test conditions: Console.assert() console.assert(x > 0, 'x must be greater than zero'); console.assert(x > 0, 'x must be greater than zero'); In the browser, a failed assertion appears as an error, similar to a console.error. An added benefit is that assertions can be stripped from production builds, removing any performance impact. This makes assertions a great tool for enforcing design contracts during development without compromising production efficiency. Copying Objects to the Clipboard Copying Objects to the Clipboard Debugging often involves inspecting objects, and the copy(object) method allows you to copy an object’s content to the clipboard for external use. This feature is useful when you need to transfer data or analyze it outside the browser. copy(object) Inspecting With console.dir() and dirxml() Inspecting With console.dir() and dirxml() The console.dir() method provides a more detailed view of objects, showing their properties as you’d see in a debugger. This is particularly helpful for inspecting DOM elements or exploring API responses. Meanwhile, console.dirxml() allows you to view objects as XML, which can be useful when debugging HTML structures. console.dir() console.dirxml() Counting Function Calls Counting Function Calls Keeping track of how often a function is called or a code block is executed can be crucial. The console.count() method tracks the number of times it’s invoked, helping you verify that functions are called as expected: console.count() function myFunction() {
    console.count('myFunction called');
} function myFunction() {
    console.count('myFunction called');
} You can reset the counter using console.countReset() . This simple tool can help you catch performance issues or confirm the correct execution flow. console.countReset() Organizing Logs With Groups Organizing Logs With Groups To prevent log clutter, use console groups to organize related messages. console.group() starts a collapsible log section, and console.groupEnd() closes it: console.group() console.groupEnd() console.group('My Group');
console.log('Message 1');
console.log('Message 2');
console.groupEnd(); console.group('My Group');
console.log('Message 1');
console.log('Message 2');
console.groupEnd(); Grouping makes it easier to navigate complex logs and keeps your console clean. Chrome-Specific Debugging Features Chrome-Specific Debugging Features Monitoring Functions : Chrome’s monitor() method logs every call to a function, showing the arguments and enabling a method-tracing experience. Monitoring Functions monitor() Monitoring Events : Using monitorEvents() , you can log events on an element. This is useful for debugging UI interactions. For example, monitorEvents(window, 'mouseout') logs only mouseout events. Monitoring Events monitorEvents() monitorEvents(window, 'mouseout') mouseout Querying Object Instances : queryObjects(Constructor) lists all objects created with a specific constructor, giving you insights into memory usage and object instantiation. Querying Object Instances queryObjects(Constructor) Final Word Final Word Front-end debugging tools have come a long way. These tools provide a rich set of features that go far beyond simple console.log() statements. From log levels and CSS styling to assertions and event monitoring, mastering these techniques can transform your debugging workflow. console.log() If you read this post as part of my series, you will notice a big change in my attitude toward debugging when we reached the front end. Front-end debugging is very different when compared to back-end debugging. When debugging the backend, I’m vehemently against code changes for debugging (e.g. println debugging), but on the front end, this can be a reasonable hack. The change in environment justifies it. The short lifecycle, the single-user use case, and the risk is smaller. While there are many transferrable skills we pick up while debugging, it’s important to remain flexible in our attitude. Next time, we will discuss networking and storage debugging on the front end.

Front-End Debugging Part 2: Console.log() to the Max Explained

Working with Environment Variables in Frontend Application Releases

በFrontend መተግበሪያ ልቀቶች ውስጥ ከአካባቢ ተለዋዋጮች ጋር መስራት

Rad s varijablama okruženja u izdanjima Frontend aplikacija

Εργασία με μεταβλητές περιβάλλοντος στις εκδόσεις εφαρμογών Frontend

Cómo trabajar con variables de entorno en versiones de aplicaciones frontend

フロントエンドアプリケーションリリースでの環境変数の操作

Frontend қолданбаларының шығарылымдарында орта айнымалыларымен жұмыс істеу

Darbas su aplinkos kintamaisiais Frontend programų leidimuose

Работа с переменными среды в выпусках фронтенд-приложений

Kushanda neEnvironment Variables muFrontend Application Releases

การทำงานกับตัวแปรสภาพแวดล้อมในการเผยแพร่แอปพลิเคชัน Frontend

ምስ ተለዋዋጢ ከባቢ ኣብ ፍሮንቴንድ ኣፕሊኬሽን ሪሊዝ ምስራሕ

فرنٹ اینڈ ایپلیکیشن ریلیز میں ماحولیاتی متغیرات کے ساتھ کام کرنا

HackerNoon: What is your company in 2–5 words? Daniel Gorlovetsky: TLVTech is a tech partner for startups. Why is now the time for your company to exist? It's easier than ever to start a business in 2024. Starting a business (tech or non-tech) introduces many challenges to the founding team, we want to take a big chunk of challenges off them. What do you love about your team, and why are you the ones to solve this problem? Our team is based in the startup nation, we live innovation and take a business-first approach. Instead of you investing in deep R&D, we look for solutions. Instead of you building R&D processes, we focus on unlocking the company potential. If you weren’t building your startup, what would you be doing? Running a gym. At the moment, how do you measure success? What are your metrics? Our clients' success is our success. Our clients are thriving through these difficult years with our help, building products that reach millions of users and enterprises globally, showing great revenues and traction. In a few sentences, what do you offer to whom? We provide a full ownership of Product and R&D teams to companies that look to innovate, whether they are Seed round, or post-IPO. What’s most exciting about your traction to date? We've organically grown from 0 to 50 employees, without spending a single dollar on marketing. Where do you think your growth will be next year? We're doubling-down on AI, on multiple fronts. We expect to double our revenue in 2025. Tell us about your first paying customer and revenue expectations over the next year. Our first paying customer was a blockchain startup that needed our company to take ownership of the entire technology of their company. What’s your biggest threat? Our business is built on a great company culture and an amazing team. As long as we keep that - we'll continue to win. HackerNoon: What is your company in 2–5 words? HackerNoon: What is your company in 2–5 words? Daniel Gorlovetsky: TLVTech is a tech partner for startups. Daniel Gorlovetsky : Daniel Gorlovetsky TLVTech Why is now the time for your company to exist? Why is now the time for your company to exist? It's easier than ever to start a business in 2024. Starting a business (tech or non-tech) introduces many challenges to the founding team, we want to take a big chunk of challenges off them. What do you love about your team, and why are you the ones to solve this problem? What do you love about your team, and why are you the ones to solve this problem? Our team is based in the startup nation, we live innovation and take a business-first approach. Instead of you investing in deep R&D, we look for solutions. Instead of you building R&D processes, we focus on unlocking the company potential. If you weren’t building your startup, what would you be doing? If you weren’t building your startup, what would you be doing? Running a gym. At the moment, how do you measure success? What are your metrics? At the moment, how do you measure success? What are your metrics? Our clients' success is our success. Our clients are thriving through these difficult years with our help, building products that reach millions of users and enterprises globally, showing great revenues and traction. In a few sentences, what do you offer to whom? In a few sentences, what do you offer to whom? We provide a full ownership of Product and R&D teams to companies that look to innovate, whether they are Seed round, or post-IPO. What’s most exciting about your traction to date? What’s most exciting about your traction to date? We've organically grown from 0 to 50 employees, without spending a single dollar on marketing. Where do you think your growth will be next year? Where do you think your growth will be next year? We're doubling-down on AI, on multiple fronts. We expect to double our revenue in 2025. Tell us about your first paying customer and revenue expectations over the next year. Tell us about your first paying customer and revenue expectations over the next year. Our first paying customer was a blockchain startup that needed our company to take ownership of the entire technology of their company. What’s your biggest threat? What’s your biggest threat? Our business is built on a great company culture and an amazing team. As long as we keep that - we'll continue to win.

"We're doubling-down on AI, on multiple fronts" says Founder & CEO of TLVTech 

„Wir verstärken unsere Bemühungen im Bereich KI an mehreren Fronten“, sagt Gründer und CEO von TLVTech

"Estamos redoblando nuestra apuesta por la IA en múltiples frentes", afirma el fundador y director ejecutivo de TLVTech

«Մենք կրկնապատկվում ենք արհեստական ինտելեկտի վրա, մի քանի ուղղություններով», - ասում է TLVTech-ի հիմնադիր և գործադիր տնօրենը 

「私たちはAIに複数の面で注力しています」とTLVTechの創設者兼CEOは語る

TLVTech негізін қалаушы және бас директоры: «Біз AI-ны бірнеше бағытта екі есеге арттырамыз» дейді 

TLVTech компаниясынын негиздөөчүсү жана башкы директору: "Биз AI тармагын эки эсеге көбөйтүп жатабыз" дейт 

"Mitombo avo roa heny izahay amin'ny AI, amin'ny lafiny maro" hoy ny Mpanorina & Tale Jeneralin'ny TLVTech 

"We verdubbelen onze inzet op AI, op meerdere fronten", zegt oprichter en CEO van TLVTech

"Estamos dobrando a aposta na IA em várias frentes", diz o fundador e CEO da TLVTech

«Мы удваиваем ставку на ИИ на нескольких фронтах», — говорит основатель и генеральный директор TLVTech

Fondateri & CEO wa TLVTech agira ati: "Turimo kwikuba kabiri kuri AI, ku mpande nyinshi" 

"Waxaan ku labanlaabaynaa AI, dhinacyo badan" ayuu yiri aasaasaha & maamulaha TLVTech 

As a Java developer, most of my focus is on the backend side of debugging. Front-end debugging poses different challenges and has sophisticated tools of its own. Unfortunately, print-based debugging has become the norm in front-end. To be fair, it makes more sense there as the cycles are different and the problem is always a single-user problem. But even if you choose to use Console.log, there’s a lot of nuance to pick up there. The links in this article include affiliate links to Amazon. You won’t be charged anything extra for clicking on these links, but you will be supporting me if you do choose to purchase something through one of these links. Thanks! https://youtu.be/1KFlbecOmc0?embedable=true As a side note, if you like the content of this and the other posts in this series check out my Debugging book that covers this subject. If you have friends that are learning to code I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while check out my Java 8 to 21 book. Instant Debugging with the debugger Keyword A cool yet powerful tool in JavaScript is the debugger keyword. Instead of simply printing a stack trace, we can use this keyword to launch the debugger directly at the line of interest. That is a fantastic tool that instantly brings your attention to a bug, I often use it in my debug builds of the front-end instead of just printing an error log. How to Use It: Place the debugger keyword within your code, particularly within error-handling methods. When the code execution hits this line, it automatically pauses, allowing you to inspect the current state, step through code, and understand what's going wrong. Notice that while this is incredibly useful during development, we must remember to remove or conditionally exclude debugger statements in production environments. A release build should not include these calls in a production site live environment. Triggering Debugging from the Console Modern browsers allow you to invoke debugging directly from the console, adding an additional layer of flexibility to your debugging process. Example: By using the debug(functionName) command in the console, you can set a breakpoint at the start of the specified function. When this function is subsequently invoked, the execution halts, sending you directly into the debugger. function hello(name) {
    Console.log("Hello " + name)
}
debug(hello)
hello("Shai") This is particularly useful when you want to start debugging without modifying the source code, or when you need to inspect a function that’s only defined in the global scope. DOM Breakpoints: Monitoring DOM Changes DOM breakpoints are an advanced feature in Chrome and Firebug (Firefox plugin) that allows you to pause execution when a specific part of the DOM is altered. To use it we can right-click on the desired DOM element, select “Break On,” and choose the specific mutation type you are interested in (e.g., subtree modifications, attribute changes, etc.). DOM breakpoints are extremely powerful for tracking down issues where DOM manipulation causes unexpected results, such as dynamic content loading or changes in the user interface that disrupt the intended layout or functionality. Think of them like field breakpoints we discussed in the past. These breakpoints complement traditional line and conditional breakpoints, providing a more granular approach to debugging complex front-end issues. This is a great tool to use when the DOM is manipulated by an external dependency. XHR Breakpoints: Uncovering Hidden Network Calls Understanding who initiates specific network requests can be challenging, especially in large applications with multiple sources contributing to a request. XHR (XMLHttpRequest) breakpoints provide a solution to this problem. In Chrome or Firebug, set an XHR breakpoint by specifying a substring of the URI you wish to monitor. When a request matching this pattern is made, the execution stops, allowing you to investigate the source of the request. This tool is invaluable when dealing with dynamically generated URIs or complex flows where tracking the origin of a request is not straightforward. Notice that you should be selective with the filters you set; leaving the filter blank will cause the breakpoint to trigger on all XHR requests, which can become overwhelming. Simulating Environments for Debugging Sometimes, the issues you need to debug are specific to certain environments, such as mobile devices or different geographical locations. Chrome and Firefox offer several simulation tools to help you replicate these conditions on your desktop. Simulating User Agents: Change the browser’s user agent to mimic different devices or operating systems. This can help you identify platform-specific issues or debug server-side content delivery that varies by user agent.


Geolocation Spoofing: Modify the browser’s reported location to test locale-specific features or issues. This is particularly useful for applications that deliver region-specific content or services.


Touch and Device Orientation Emulation: Simulate touch events or change the device orientation to see how your application responds to mobile-specific interactions. This is crucial for ensuring a seamless user experience across all devices. These are things that are normally very difficult to reproduce. E.g. touch related issues are often challenging to debug on the device. By simulating them on the desktop browser we can shorten the debug cycle and use the tooling available on the desktop. Debugging Layout and Style Issues CSS and HTML bugs can be particularly tricky, often requiring a detailed examination of how elements are rendered and styled. Inspect Element: The "inspect element" tool is the cornerstone of front-end debugging, allowing you to view and manipulate the DOM and CSS in real-time. As you make changes, the page updates instantly, providing immediate feedback on your tweaks.


Addressing Specificity Issues: One common problem is CSS specificity, where a more specific selector overrides the styles you intend to apply. The inspect element view highlights overridden styles, helping you identify and resolve conflicts.


Firefox vs. Chrome: While both browsers offer robust tools, they have different approaches to organizing these features. Firefox’s interface may seem more straightforward, with fewer tabs, while Chrome organizes similar tools under various tabs, which can either streamline your workflow or add complexity, depending on your preference. Final Word There are many front-end tools that I want to discuss in the coming posts. I hope you picked up a couple of new debugging tricks in this first part. Front-end debugging requires a deep understanding of browser tools and JavaScript capabilities. By mastering the techniques outlined in this post—instant debugging with the debugger keyword, DOM and XHR breakpoints, environment simulation, and layout inspection—you can significantly enhance your debugging efficiency and deliver more robust, error-free web applications. As a Java developer, most of my focus is on the backend side of debugging. Front-end debugging poses different challenges and has sophisticated tools of its own. Unfortunately, print-based debugging has become the norm in front-end. To be fair, it makes more sense there as the cycles are different and the problem is always a single-user problem. But even if you choose to use Console.log , there’s a lot of nuance to pick up there. Console.log The links in this article include affiliate links to Amazon. You won’t be charged anything extra for clicking on these links, but you will be supporting me if you do choose to purchase something through one of these links. Thanks! The links in this article include affiliate links to Amazon. You won’t be charged anything extra for clicking on these links, but you will be supporting me if you do choose to purchase something through one of these links. Thanks! https://youtu.be/1KFlbecOmc0?embedable=true https://youtu.be/1KFlbecOmc0?embedable=true As a side note, if you like the content of this and the other posts in this series check out my Debugging book that covers this subject. If you have friends that are learning to code I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while check out my Java 8 to 21 book. As a side note, if you like the content of this and the other posts in this series check out my Debugging book that covers t his subject. If you have friends that are learning to code I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while check out my Java 8 to 21 book . Debugging book t Java Basics book. Java 8 to 21 book . Instant Debugging with the debugger Keyword Instant Debugging with the debugger A cool yet powerful tool in JavaScript is the debugger keyword. Instead of simply printing a stack trace, we can use this keyword to launch the debugger directly at the line of interest. That is a fantastic tool that instantly brings your attention to a bug, I often use it in my debug builds of the front-end instead of just printing an error log. debugger How to Use It: Place the debugger keyword within your code, particularly within error-handling methods. When the code execution hits this line, it automatically pauses, allowing you to inspect the current state, step through code, and understand what's going wrong. How to Use It: debugger Notice that while this is incredibly useful during development, we must remember to remove or conditionally exclude debugger statements in production environments. A release build should not include these calls in a production site live environment. debugger Triggering Debugging from the Console Triggering Debugging from the Console Modern browsers allow you to invoke debugging directly from the console, adding an additional layer of flexibility to your debugging process. Example: By using the debug(functionName) command in the console, you can set a breakpoint at the start of the specified function. When this function is subsequently invoked, the execution halts, sending you directly into the debugger. Example: debug(functionName) function hello(name) {
    Console.log("Hello " + name)
}
debug(hello)
hello("Shai") function hello(name) {
    Console.log("Hello " + name)
}
debug(hello)
hello("Shai") This is particularly useful when you want to start debugging without modifying the source code, or when you need to inspect a function that’s only defined in the global scope. DOM Breakpoints: Monitoring DOM Changes DOM Breakpoints: Monitoring DOM Changes DOM breakpoints are an advanced feature in Chrome and Firebug (Firefox plugin) that allows you to pause execution when a specific part of the DOM is altered. To use it we can right-click on the desired DOM element, select “Break On,” and choose the specific mutation type you are interested in (e.g., subtree modifications, attribute changes, etc.). DOM breakpoints are extremely powerful for tracking down issues where DOM manipulation causes unexpected results, such as dynamic content loading or changes in the user interface that disrupt the intended layout or functionality. Think of them like field breakpoints we discussed in the past. These breakpoints complement traditional line and conditional breakpoints, providing a more granular approach to debugging complex front-end issues. This is a great tool to use when the DOM is manipulated by an external dependency. XHR Breakpoints: Uncovering Hidden Network Calls XHR Breakpoints: Uncovering Hidden Network Calls Understanding who initiates specific network requests can be challenging, especially in large applications with multiple sources contributing to a request. XHR ( XMLHttpRequest ) breakpoints provide a solution to this problem. XMLHttpRequest In Chrome or Firebug, set an XHR breakpoint by specifying a substring of the URI you wish to monitor. When a request matching this pattern is made, the execution stops, allowing you to investigate the source of the request. This tool is invaluable when dealing with dynamically generated URIs or complex flows where tracking the origin of a request is not straightforward. Notice that you should be selective with the filters you set; leaving the filter blank will cause the breakpoint to trigger on all XHR requests, which can become overwhelming. Simulating Environments for Debugging Simulating Environments for Debugging Sometimes, the issues you need to debug are specific to certain environments, such as mobile devices or different geographical locations. Chrome and Firefox offer several simulation tools to help you replicate these conditions on your desktop. Simulating User Agents: Change the browser’s user agent to mimic different devices or operating systems. This can help you identify platform-specific issues or debug server-side content delivery that varies by user agent. Geolocation Spoofing: Modify the browser’s reported location to test locale-specific features or issues. This is particularly useful for applications that deliver region-specific content or services. Touch and Device Orientation Emulation: Simulate touch events or change the device orientation to see how your application responds to mobile-specific interactions. This is crucial for ensuring a seamless user experience across all devices. Simulating User Agents: Change the browser’s user agent to mimic different devices or operating systems. This can help you identify platform-specific issues or debug server-side content delivery that varies by user agent. Simulating User Agents: Change the browser’s user agent to mimic different devices or operating systems. This can help you identify platform-specific issues or debug server-side content delivery that varies by user agent. Simulating User Agents: Geolocation Spoofing: Modify the browser’s reported location to test locale-specific features or issues. This is particularly useful for applications that deliver region-specific content or services. Geolocation Spoofing: Modify the browser’s reported location to test locale-specific features or issues. This is particularly useful for applications that deliver region-specific content or services. Geolocation Spoofing: Touch and Device Orientation Emulation: Simulate touch events or change the device orientation to see how your application responds to mobile-specific interactions. This is crucial for ensuring a seamless user experience across all devices. Touch and Device Orientation Emulation: Simulate touch events or change the device orientation to see how your application responds to mobile-specific interactions. This is crucial for ensuring a seamless user experience across all devices. Touch and Device Orientation Emulation: These are things that are normally very difficult to reproduce. E.g. touch related issues are often challenging to debug on the device. By simulating them on the desktop browser we can shorten the debug cycle and use the tooling available on the desktop. Debugging Layout and Style Issues Debugging Layout and Style Issues CSS and HTML bugs can be particularly tricky, often requiring a detailed examination of how elements are rendered and styled. Inspect Element: The "inspect element" tool is the cornerstone of front-end debugging, allowing you to view and manipulate the DOM and CSS in real-time. As you make changes, the page updates instantly, providing immediate feedback on your tweaks. Addressing Specificity Issues: One common problem is CSS specificity, where a more specific selector overrides the styles you intend to apply. The inspect element view highlights overridden styles, helping you identify and resolve conflicts. Firefox vs. Chrome: While both browsers offer robust tools, they have different approaches to organizing these features. Firefox’s interface may seem more straightforward, with fewer tabs, while Chrome organizes similar tools under various tabs, which can either streamline your workflow or add complexity, depending on your preference. Inspect Element: The "inspect element" tool is the cornerstone of front-end debugging, allowing you to view and manipulate the DOM and CSS in real-time. As you make changes, the page updates instantly, providing immediate feedback on your tweaks. Inspect Element: The "inspect element" tool is the cornerstone of front-end debugging, allowing you to view and manipulate the DOM and CSS in real-time. As you make changes, the page updates instantly, providing immediate feedback on your tweaks. Inspect Element: Addressing Specificity Issues: One common problem is CSS specificity, where a more specific selector overrides the styles you intend to apply. The inspect element view highlights overridden styles, helping you identify and resolve conflicts. Addressing Specificity Issues: One common problem is CSS specificity, where a more specific selector overrides the styles you intend to apply. The inspect element view highlights overridden styles, helping you identify and resolve conflicts. Addressing Specificity Issues: Firefox vs. Chrome: While both browsers offer robust tools, they have different approaches to organizing these features. Firefox’s interface may seem more straightforward, with fewer tabs, while Chrome organizes similar tools under various tabs, which can either streamline your workflow or add complexity, depending on your preference. Firefox vs. Chrome: While both browsers offer robust tools, they have different approaches to organizing these features. Firefox’s interface may seem more straightforward, with fewer tabs, while Chrome organizes similar tools under various tabs, which can either streamline your workflow or add complexity, depending on your preference. Firefox vs. Chrome: Final Word There are many front-end tools that I want to discuss in the coming posts. I hope you picked up a couple of new debugging tricks in this first part. Front-end debugging requires a deep understanding of browser tools and JavaScript capabilities. By mastering the techniques outlined in this post—instant debugging with the debugger keyword, DOM and XHR breakpoints, environment simulation, and layout inspection—you can significantly enhance your debugging efficiency and deliver more robust, error-free web applications. debugger

Mastering Front End Debugging—Part 1: From Console Logs to Advanced Techniques 

I’ve been working in IT for 10 years, and for the past 5 years as a Lead Developer. I’ve conducted over 100 technical interviews for various projects and technologies. I think, that Interviews often says more about the interviewer than about the actual project and what tasks you would be assigned. It’s frustrating when interviewers ask questions like “How do you handle memory leaks in a browser?” or “What project metrics should be tracked?” Then, for a long time, you working on building web forms and changing button colors 🙃 Target Audience I do not recommend this article for people who are preparing for interviews, because most interviews focus on a lot of theory that doesn’t really relate to the project or work you’ll actually do. I hope this will be interesting for those looking for an optimal way to conduct interviews and find the best candidates in the market. This rules and questions were defined after a big amount of hiring bad specialists, that perform really bad on the project. As for now, I can be sure that using this questions, even if candidate know before interview them, I will understand if I can work with this person and will the candidate be able to handle the project tasks. Interview Rules Ask Only What You Need to Know Make the PLAN! You should understand why you hire someone and what this person would do on project. If you’re hiring someone just to write HTML/CSS, ask relevant questions. You probably expect them to analyse requirements before implementation. Your goal is to hire someone who can work independently, so don’t waste time explaining every detail of what they need to do. If you need a candidate that will change the build process on you project and split application into microfrontends, then it ok if candidate has some gaps in css, when specific tasks would be ended you can hire a new one or upskill your teammate. Don’t Ask What Can Be Googled It’s strange to hear questions like “What does function X do?” or “How many JavaScript types are there?” If the candidate doesn’t know the latest features like private methods or symbols in JS, it’s usually not a reason to reject them, until you are banned in google or ChatGPT and all your teammates are junior developers. Ensure the Candidate is Ready to Learn the Project Stack Sometimes it’s critical, like if you’re hiring a backend developer for a project with a SQL database but no ORM. In that case, SQL knowledge is essential. However, if you’re using Firebase, SQL might not matter. If a candidate has some backend experience, give them 1-2 days to learn Firebase. It hard to find candidate that will match all your project skill set, especially when project exists for more then 5 years. Evaluate How Candidates Think Nobody knows everything, but some people are quick learners and adaptable. I prefer hiring people who show a willingness to learn and grow. It better to understand if candidate can solve complicated tasks or will rather give up on easy one. If their knowledge covers at least 70% of what you need, check if they can learn new tools, solve complex problems, and apply their skills. Remember the candidate level It not relevant to ask junior developer: how to setup datadog dashboard and what metrics to collect. As for me, I have following expectations from candidates level: Junior Developer: Has good theoretical knowledge and can apply it in practice. Has limited practical experience;
Software Developer: Can work independently on most tasks. Has solid practical experience for at least one year;
Senior Developer: Should have strong and deep technical knowledge and be able to mentor junior developers. Ideally capable of creating good solution designs. Has good communication skills;
Lead Developer: Similar to a senior developer but can also manage the team. In my view, they should also act as a junior architect and junior project manager, supporting both the PM and architect effectively. Ask Simple Theory Questions I’m not a fan of theory, but I do ask basic questions to ensure candidates understand the main tech stack. For example: For a React position: •	How does change detection work in React?

•	How do you use useState and useEffect?

•	What’s the difference between props and state? For an Angular position: •	How does change detection work, and what strategy do you use?

•	Can you explain the component lifecycle?

•	What is two-way data binding, and what is @Input? Once candidates show a basic understanding, I might ask more advanced questions based on the project’s specific needs. Practical Coding Tasks I’ve heard complaints about coding during interviews, but I’ve found it helpful. Remember to help candidate to keep calm if candidate got too nervous! Part 0: Using the Console I often start by asking the candidate to download a project from GitHub. This helps me understand how they navigate the console, switch between screens, and more. Here’s what I look for: •	How they download the code – do they use an efficient method?

•	Do they check the README file for setup instructions? Part 1: Problem-Solving The first task might be to create a simple blog. •	How many questions the candidate asks – are they relevant?

•	Do they prioritize tasks effectively?

•	How is the CSS structured, and are they using best practices?

•	How do they approach the task? Do they start with a basic structure and then refine it? Part 2: Handling Challenges I also give a task to fix unit tests, which helps me see how candidates handle difficulties and work with legacy code. •	How they debug and use the console.

•	Their approach to writing unit tests. Conclusion With these tasks, I get a good understanding of how candidates think and how they use tools like the code editor, console, JavaScript, frameworks. Based on this, I decide if they’re a good fit for the team, the project and for me as a lead. I’ve been working in IT for 10 years, and for the past 5 years as a Lead Developer. I’ve conducted over 100 technical interviews for various projects and technologies. I think, that Interviews often says more about the interviewer than about the actual project and what tasks you would be assigned. It’s frustrating when interviewers ask questions like “How do you handle memory leaks in a browser?” or “What project metrics should be tracked?” Then, for a long time, you working on building web forms and changing button colors 🙃 Target Audience I do not recommend this article for people who are preparing for interviews, because most interviews focus on a lot of theory that doesn’t really relate to the project or work you’ll actually do. I hope this will be interesting for those looking for an optimal way to conduct interviews and find the best candidates in the market. This rules and questions were defined after a big amount of hiring bad specialists, that perform really bad on the project. As for now, I can be sure that using this questions, even if candidate know before interview them, I will understand if I can work with this person and will the candidate be able to handle the project tasks. Interview Rules Ask Only What You Need to Know Make the PLAN! You should understand why you hire someone and what this person would do on project. If you’re hiring someone just to write HTML/CSS, ask relevant questions. You probably expect them to analyse requirements before implementation. Your goal is to hire someone who can work independently, so don’t waste time explaining every detail of what they need to do. If you need a candidate that will change the build process on you project and split application into microfrontends, then it ok if candidate has some gaps in css, when specific tasks would be ended you can hire a new one or upskill your teammate. Don’t Ask What Can Be Googled It’s strange to hear questions like “What does function X do?” or “How many JavaScript types are there?” If the candidate doesn’t know the latest features like private methods or symbols in JS, it’s usually not a reason to reject them, until you are banned in google or ChatGPT and all your teammates are junior developers. Ensure the Candidate is Ready to Learn the Project Stack Sometimes it’s critical, like if you’re hiring a backend developer for a project with a SQL database but no ORM. In that case, SQL knowledge is essential. However, if you’re using Firebase, SQL might not matter. If a candidate has some backend experience, give them 1-2 days to learn Firebase. It hard to find candidate that will match all your project skill set, especially when project exists for more then 5 years. Evaluate How Candidates Think Nobody knows everything, but some people are quick learners and adaptable. I prefer hiring people who show a willingness to learn and grow. It better to understand if candidate can solve complicated tasks or will rather give up on easy one. If their knowledge covers at least 70% of what you need, check if they can learn new tools, solve complex problems, and apply their skills. Remember the candidate level It not relevant to ask junior developer: how to setup datadog dashboard and what metrics to collect. As for me, I have following expectations from candidates level: Junior Developer: Has good theoretical knowledge and can apply it in practice. Has limited practical experience; Software Developer: Can work independently on most tasks. Has solid practical experience for at least one year; Senior Developer: Should have strong and deep technical knowledge and be able to mentor junior developers. Ideally capable of creating good solution designs. Has good communication skills; Lead Developer: Similar to a senior developer but can also manage the team. In my view, they should also act as a junior architect and junior project manager, supporting both the PM and architect effectively. Junior Developer: Has good theoretical knowledge and can apply it in practice. Has limited practical experience; Software Developer: Can work independently on most tasks. Has solid practical experience for at least one year; Senior Developer: Should have strong and deep technical knowledge and be able to mentor junior developers. Ideally capable of creating good solution designs. Has good communication skills; Lead Developer: Similar to a senior developer but can also manage the team. In my view, they should also act as a junior architect and junior project manager, supporting both the PM and architect effectively. Ask Simple Theory Questions I’m not a fan of theory, but I do ask basic questions to ensure candidates understand the main tech stack. For example: For a React position: •	How does change detection work in React?

•	How do you use useState and useEffect?

•	What’s the difference between props and state? •	How does change detection work in React?

•	How do you use useState and useEffect?

•	What’s the difference between props and state? For an Angular position: •	How does change detection work, and what strategy do you use?

•	Can you explain the component lifecycle?

•	What is two-way data binding, and what is @Input? •	How does change detection work, and what strategy do you use?

•	Can you explain the component lifecycle?

•	What is two-way data binding, and what is @Input? Once candidates show a basic understanding, I might ask more advanced questions based on the project’s specific needs. Practical Coding Tasks I’ve heard complaints about coding during interviews, but I’ve found it helpful. Remember to help candidate to keep calm if candidate got too nervous! Remember to help candidate to keep calm if candidate got too nervous! Part 0: Using the Console I often start by asking the candidate to download a project from GitHub. This helps me understand how they navigate the console, switch between screens, and more. Here’s what I look for: •	How they download the code – do they use an efficient method?

•	Do they check the README file for setup instructions? •	How they download the code – do they use an efficient method?

•	Do they check the README file for setup instructions? Part 1: Problem-Solving The first task might be to create a simple blog. •	How many questions the candidate asks – are they relevant?

•	Do they prioritize tasks effectively?

•	How is the CSS structured, and are they using best practices?

•	How do they approach the task? Do they start with a basic structure and then refine it? •	How many questions the candidate asks – are they relevant?

•	Do they prioritize tasks effectively?

•	How is the CSS structured, and are they using best practices?

•	How do they approach the task? Do they start with a basic structure and then refine it? Part 2: Handling Challenges I also give a task to fix unit tests, which helps me see how candidates handle difficulties and work with legacy code. •	How they debug and use the console.

•	Their approach to writing unit tests. •	How they debug and use the console.

•	Their approach to writing unit tests. Conclusion With these tasks, I get a good understanding of how candidates think and how they use tools like the code editor, console, JavaScript, frameworks. Based on this, I decide if they’re a good fit for the team, the project and for me as a lead.

My Favourite Front-End Interview Question to Ask Candidates and Why

When a project needs to be split How do successful projects usually get started? Quickly, without long discussions, in startup mode: we build features and deal with technical debt later. Under such conditions, it’s hard to establish an architecture that would allow the project to continue evolving after 5–7 years. The frontend part of our project was no exception. In this article, I’ll explain how we transitioned from a classic React application to a truly big project. So, we had a typical React 17 app. Redux + logic in thunks and middlewares. Custom SSR on Express. The project was actively growing, attracting new users, and gaining functionality. The complexity of the code increased, and after the Series A round of funding, the company allowed us to allocate up to 15% of our time to technical tasks. At this stage, the product development team began to split into “units”—this is what we call the teams which handle the app’s functionality (a specific user role or scenario). At this point, the frontend project saw its first optimisations: Client-side lazy loading of components
Optimising the Redux middleware call stack These optimisations allowed us to add new features to our React app for a few more years. The project eventually got Series B funding, so the number of frontend developers reached 30 and the size of the main bundle grew to 300 KB. The code's interdependence and task complexity indicated that it was time to break the app into parts. We started by improving the asynchronous loading of components using React Loadable. This allowed us to load not just components asynchronously but entire pages. React Loadable gave us the ability, with our SSR, to understand which parts of the app were touched when rendering the HTML, collect those JS files, and load them before the first client render. After that, we realised that the main issue was in the middleware and thunks, not in the code of our pages. So, we began splitting the business logic within them. Getting started We decided to divide the project into modules using a modern tool for microfrontends. Here are the challenges we faced: SSR Build — Most microfrontend tools didn’t support server-side rendering (SSR), so we manually adjusted the process to ensure all modules were bundled together during SSR.
Integration with Loadable — We needed a mechanism to determine which parts of the app were affected during SSR, so we had to integrate Loadable with the SSR modules. Since each module represented an independent Webpack build, Loadable couldn’t correlate the chunk names it needed with those already loaded out of the box. To fix this, we wrote a small Webpack plugin that preserved shared chunk names. We then exported the Webpack Stats file and taught Loadable to look for the necessary chunks across other modules during SSR. At this point, we had a 4 KB overhead per module and a few asynchronous pages using the microfrontend tool, but it still didn’t solve the main issue—splitting the business logic. In the end, we put a lot of effort into implementing the tool without gaining significant optimizations. This happened because, regardless of the tool you use, what’s most important is how you logically split the app’s parts. After that, we moved on to directly dividing the business logic, having first solved a few related issues. Data sharing What’s stopping us from separating a module from our app? First of all, the shared stores. Let’s look at this problem using the example of the ‘users’ store. It looks something like this: export type IUsersState = Record<IUserId, IUser>;
export const initialState: IUsersState = {}
export default function reducer(
    state: IUsersState = initialState,
    action: IAppAction,
): IUsersState {
    switch (action.type) {
        case USERS_SAVE: {
            return {
                ...state,
                ...action.users.reduce((acc, user) => {
                    acc[user.id] = user;
                    return acc;
                })
            }
        }
        // ...
    }
}; Each of our future modules uses such a store in roughly the following way. UserIds are stored in objects used by our module, and in selectors, we fill them with data from the users store. Why was it done this way at the start of the project? For convenience, caching, and data normalisation. Data from modules is stored in one place and, in some cases, can be reused from the cache instead of being requested again. The problem is that such a reducer is part of the common store, and if all modules have access to the shared store, it increases module interdependence. So, we extracted such reducers into separate stores using Zustand. This allowed us to isolate modules from data they didn’t need, while maintaining data sharing and reactivity between modules. Event sharing between modules The next issue we solved was shared middleware. Let’s break this down using the example of socket middleware. As the name suggests, this middleware processes events coming through a WebSocket connection. The problem is that this single middleware processes events for the stores of almost all modules. We reorganized it as follows: we created a separate event bus based on EventEmitter, independent of Redux, and now the module that maintains the WebSocket connection produces messages straight into the event bus. This way, we managed to split the common logic and distribute it across modules. An important point here: when switching from dispatching events to EventEmitter, you don’t need to migrate all events, just those used in multiple modules. Events that happen and are handled within one module don’t need to be migrated to EventEmitter. It’s crucial to understand the list of modules you want to isolate. A few more things to mention Upgrading to React 18 allowed us to remove some of the functionality of Loadable: there’s no longer a need to wait for all necessary chunks to load before performing the first render.
In order to reuse styles in common components, such as buttons (Button), we created a component library and started reusing them across the app. After solving these issues, we began splitting the business logic into modules, reflecting the structure of how our company is divided into teams and areas of responsibility. Conclusion Our mistake was starting with a tool before logically dividing the modules. The correct order for modularisation in our case would have been: Logically divide the project into modules: make a list of modules.
Solve the main issues with shared stores, events, and the base component library.
Actually split the business logic.
Implement improvements that are possible due to the modular system: separate deployment, isolation, etc. And in conclusion, I want to wish good luck to everyone who is starting to split their application into modules. It's a long journey, but the result is worth it. When a project needs to be split When a project needs to be split How do successful projects usually get started? Quickly, without long discussions, in startup mode: we build features and deal with technical debt later. Under such conditions, it’s hard to establish an architecture that would allow the project to continue evolving after 5–7 years. The frontend part of our project was no exception. In this article, I’ll explain how we transitioned from a classic React application to a truly big project. So, we had a typical React 17 app. Redux + logic in thunks and middlewares. Custom SSR on Express. The project was actively growing, attracting new users, and gaining functionality. The complexity of the code increased, and after the Series A round of funding, the company allowed us to allocate up to 15% of our time to technical tasks. At this stage, the product development team began to split into “units”—this is what we call the teams which handle the app’s functionality (a specific user role or scenario). At this point, the frontend project saw its first optimisations: Client-side lazy loading of components Optimising the Redux middleware call stack Client-side lazy loading of components Optimising the Redux middleware call stack These optimisations allowed us to add new features to our React app for a few more years. The project eventually got Series B funding, so the number of frontend developers reached 30 and the size of the main bundle grew to 300 KB. The code's interdependence and task complexity indicated that it was time to break the app into parts. We started by improving the asynchronous loading of components using React Loadable. This allowed us to load not just components asynchronously but entire pages. React Loadable gave us the ability, with our SSR, to understand which parts of the app were touched when rendering the HTML, collect those JS files, and load them before the first client render. After that, we realised that the main issue was in the middleware and thunks, not in the code of our pages. So, we began splitting the business logic within them. Getting started Getting started We decided to divide the project into modules using a modern tool for microfrontends. Here are the challenges we faced: SSR Build — Most microfrontend tools didn’t support server-side rendering (SSR), so we manually adjusted the process to ensure all modules were bundled together during SSR. Integration with Loadable — We needed a mechanism to determine which parts of the app were affected during SSR, so we had to integrate Loadable with the SSR modules. Since each module represented an independent Webpack build, Loadable couldn’t correlate the chunk names it needed with those already loaded out of the box. To fix this, we wrote a small Webpack plugin that preserved shared chunk names. We then exported the Webpack Stats file and taught Loadable to look for the necessary chunks across other modules during SSR. SSR Build — Most microfrontend tools didn’t support server-side rendering (SSR), so we manually adjusted the process to ensure all modules were bundled together during SSR. SSR Build Integration with Loadable — We needed a mechanism to determine which parts of the app were affected during SSR, so we had to integrate Loadable with the SSR modules. Since each module represented an independent Webpack build, Loadable couldn’t correlate the chunk names it needed with those already loaded out of the box. To fix this, we wrote a small Webpack plugin that preserved shared chunk names. We then exported the Webpack Stats file and taught Loadable to look for the necessary chunks across other modules during SSR. Integration with Loadable At this point, we had a 4 KB overhead per module and a few asynchronous pages using the microfrontend tool, but it still didn’t solve the main issue—splitting the business logic. In the end, we put a lot of effort into implementing the tool without gaining significant optimizations. This happened because, regardless of the tool you use, what’s most important is how you logically split the app’s parts. After that, we moved on to directly dividing the business logic, having first solved a few related issues. Data sharing Data sharing What’s stopping us from separating a module from our app? First of all, the shared stores. Let’s look at this problem using the example of the ‘users’ store. It looks something like this: export type IUsersState = Record<IUserId, IUser>;
export const initialState: IUsersState = {}
export default function reducer(
    state: IUsersState = initialState,
    action: IAppAction,
): IUsersState {
    switch (action.type) {
        case USERS_SAVE: {
            return {
                ...state,
                ...action.users.reduce((acc, user) => {
                    acc[user.id] = user;
                    return acc;
                })
            }
        }
        // ...
    }
}; export type IUsersState = Record<IUserId, IUser>;
export const initialState: IUsersState = {}
export default function reducer(
    state: IUsersState = initialState,
    action: IAppAction,
): IUsersState {
    switch (action.type) {
        case USERS_SAVE: {
            return {
                ...state,
                ...action.users.reduce((acc, user) => {
                    acc[user.id] = user;
                    return acc;
                })
            }
        }
        // ...
    }
}; Each of our future modules uses such a store in roughly the following way. UserIds are stored in objects used by our module, and in selectors, we fill them with data from the users store. Why was it done this way at the start of the project? For convenience, caching, and data normalisation. Data from modules is stored in one place and, in some cases, can be reused from the cache instead of being requested again. The problem is that such a reducer is part of the common store, and if all modules have access to the shared store, it increases module interdependence. So, we extracted such reducers into separate stores using Zustand. This allowed us to isolate modules from data they didn’t need, while maintaining data sharing and reactivity between modules. Event sharing between modules Event sharing between modules The next issue we solved was shared middleware. Let’s break this down using the example of socket middleware. As the name suggests, this middleware processes events coming through a WebSocket connection. The problem is that this single middleware processes events for the stores of almost all modules. We reorganized it as follows: we created a separate event bus based on EventEmitter, independent of Redux, and now the module that maintains the WebSocket connection produces messages straight into the event bus. This way, we managed to split the common logic and distribute it across modules. An important point here: when switching from dispatching events to EventEmitter, you don’t need to migrate all events, just those used in multiple modules. Events that happen and are handled within one module don’t need to be migrated to EventEmitter. It’s crucial to understand the list of modules you want to isolate. A few more things to mention A few more things to mention Upgrading to React 18 allowed us to remove some of the functionality of Loadable: there’s no longer a need to wait for all necessary chunks to load before performing the first render. In order to reuse styles in common components, such as buttons (Button), we created a component library and started reusing them across the app. Upgrading to React 18 allowed us to remove some of the functionality of Loadable: there’s no longer a need to wait for all necessary chunks to load before performing the first render. In order to reuse styles in common components, such as buttons (Button), we created a component library and started reusing them across the app. After solving these issues, we began splitting the business logic into modules, reflecting the structure of how our company is divided into teams and areas of responsibility. Conclusion Conclusion Our mistake was starting with a tool before logically dividing the modules. The correct order for modularisation in our case would have been: Logically divide the project into modules: make a list of modules. Solve the main issues with shared stores, events, and the base component library. Actually split the business logic. Implement improvements that are possible due to the modular system: separate deployment, isolation, etc. Logically divide the project into modules: make a list of modules. Solve the main issues with shared stores, events, and the base component library. Actually split the business logic. Implement improvements that are possible due to the modular system: separate deployment, isolation, etc. And in conclusion, I want to wish good luck to everyone who is starting to split their application into modules. It's a long journey, but the result is worth it.

Our Journey to Micro-Frontends

Stories, News & Mentions about FRONT

Front’s Stories on HackerNoon

Front's News & Mentions