Culture and Methodologies

I recently came across an article arguing that programmers shouldn't be involved in solving business problems, claiming it's a harmful myth perpetuated by the industry. The author believes that focusing on business needs corrupts the pure technical nature of programming. I strongly disagree with this perspective, and here's my response based on my experience as a web developer. Developer Levels Let's start with developer levels. Unfortunately, the three well-known grades (Junior, Middle, and Senior) lack clear definitions. Every person and company defines requirements individually, with blurred boundaries that sometimes take unexpected turns. So, first, let me explain how I understand these concepts. Junior: This is the least controversial definition: a beginner programmer who has just learned theory and maybe completed a few pet projects or recently graduated from university.Middle: An experienced programmer who not only knows but truly understands the technology stack they use daily.Senior: An experienced programmer with diverse experience across multiple projects, has "production" work experience with several technology stacks, and possesses broad industry awareness. They should have experience in related fields (for example, I consider it normal when a Senior Web Developer has system administration skills) and can switch between frameworks or even programming languages without significant performance drops. Like It or Not Whether you want it or not, programmers solve business problems. Always, with rare exceptions. We need to understand that employment or self-employment always involves monetary relationships. Business needs to make profits, which includes paying employee salaries. Consequently, to generate profit, problems need to be solved (or, you could say, business tasks need to be addressed). Programmers need to make a living, preferably a good one. It's also important to understand that you can bring "value" to a business (or solve its problems) in different ways — both indirectly and directly. How It Works Let's examine a classic case and see how business problem-solving happens. A task arrives: We need to build a new website; it's nothing special. Simplified, the task flows like this: Company Head -> First-level managers -> Project Manager -> Team Lead and Designer (usually two different departments, so the task is assigned in parallel) -> Senior and/or all implementers. There are two possible approaches: Case 1: Just do what you're told, "just code" — everyone works within their direct responsibilities: Team Lead discusses with business and creates Jira tickets, Senior designs architecture and handles the most complex parts, Junior does markup, and Middle handles regular tasks, possibly complex things alongside Senior (for simplicity, all Full Stack).Case 2: Before starting work, several meetings are organized where the Senior Team Lead, designers, and management discuss the business problem in detail. They discuss not just how to solve it but how to solve it effectively for everyone — businesses, developers, and designers. They find a golden middle ground that works for everyone, and only then does development begin. The Results In the first scenario, when everyone "just codes," the business problem gets solved inefficiently. You get 100% deadline misses, hacky solutions, and responsibility shifting, followed by lengthy fixes and adding "new client wishes." This happens because people just did what business asked for. Nobody said it shouldn't be done this way — everyone worked like "cogs" within their competencies and didn't get involved in solving the business problem. There was no team here. After such projects, developers typically aren't viewed favorably. Business cares about results. Smart managers then hire Seniors who are willing to solve business problems. In the second scenario, most potential issues, which always occur, are resolved through team interaction. Not to mention that developers can radically change project implementation because businesses might misunderstand what's needed. Can problems still occur? Of course, much depends on competencies, but there will be incomparably fewer issues. Here, the business problem is also solved, but effectively. Infrastructure Projects Some suggest moving to infrastructure projects where you can "just code." This is deceptive. Developers still solve business problems, just internal ones. These are the same monetary relationships. And the problems are the same as when working on a company's external product. The difference is that infrastructure projects are usually handled according to the first case. Hence the result. But even here, business problems are being solved, and the programmer participates in solutions. Team The main difference between the first and second cases isn't in implementation but in teamwork. And by team, I mean not just a couple of coders implementing the project but the entire company. The first case shows the absence of a team; the second shows its presence — everyone works together to achieve a good result. Of course, there are many assumptions, but the world isn't perfect. Solving Business Problems ≠ Sales I don't know why, but people often associate problem-solving with sales. Yes, many tasks are related to sales, but this is just one factor and often not the most important. A programmer shouldn't think about HOW things will be sold, but they should think about WHAT will be sold. The quality of the final product depends on purely architectural decisions (which Senior often designs), response time, working logic, design (yes, programmers NEED to participate in interface design before development), etc. Even an infrastructure project is sold but within the company. The company's efficiency and consequently personal benefits (not just material ones) depend on the final product's quality. Exceptions At the beginning of the article, I mentioned that programmers solve business problems whether they want to or not, but there are exceptions. In my opinion, the only exception is pet projects - things you do for yourself. Open source projects might qualify with some stretch, but often, your commit ends up solving a business problem, just not your own. Conclusion Should a programmer solve business problems? Yes, they should. At the level of their competencies, position, and experience. Should a programmer SELL? Of course not, although it's a useful skill, especially in higher positions. Can you just code? Of course, you can. Can a Senior just code? No, for just coding, you can hire a middle developer.

Last November, I got to spend more time with my 8-year-old nephew. Since we last met, he had added another box of Legos, lots of pencils, markers, and pastels to his collection. Soon, he began showing off his home creations and schoolbook contributions with that excitement only a child can feel. Every Lego structure, every drawing, and every little craft project came with its own enthusiastic explanation. Lego instructions? Who needs them? He followed his instincts, building and creating in ways that felt right to him, unconstrained by rules or expectations. I was struck by how these simple toys and tools became, in his hands, gateways to limitless creativity. Watching him reminded me of the pure joy and freedom that come with creating something entirely your own. A Programmer's Potential Just like his collection of Legos and art supplies, we, as software developers today, have a large arsenal of tools, frameworks, and language features. The possibilities are endless, and the creative freedom is huge. What makes being a software developer truly extraordinary is the sheer expanse of possibilities. It’s not just about following a “how-to”; it’s about daring to ask “what-if.” We take raw ideas, breathe life into them through designs and code, and — if all goes well — shape them into functional applications. One of my favorite moments is when a client or team member approaches me with a challenge: “We need to achieve feature X — how would you tackle this?” That’s when my eyes light up, and with a spark of excitement, I usually reply, “Let me explore the art of the possible.” This, in those moments, is where magic happens. The process of bridging ambition with reality, experimenting with ideas, and finding creative solutions is what makes this profession always rewarding. With every new challenge that arises, more boundaries get pushed, and in discovering the as-yet-unseen, something remarkable can be created. Years ago, I had a similar conversation with a client like the one above. Here is how it went: “Hey, we need to replace our service desk application with something more robust and maintainable. Any suggestions?” I replied, “Great timing! I recently read about a new feature in the latest Java release. We can use JSP and embed Java code into a web application, which might be perfect for this.” The client responded, “That sounds possible since our service desk managers already use web apps. Let’s give it a shot.” Exciting times! I decided to create a simple application following the principle of DTSTTCPW — Do The Simplest Thing That Could Possibly Work. I developed a basic JSP that presented a form with a text field and a button. This form allowed the service desk to input data, which was then stored in a database and displayed on the web page. It was straightforward but effective. I scheduled a demo with the client. To my delight, the prototype worked flawlessly, without any demo meltdown. They were happy, and I proceeded to develop the prototype into a real web app. This initial proof of concept evolved into a comprehensive IT support management system. The system allowed service desk jobs to be handled by a Processor, which triggered the web modules, parsed the input, and generated the tickets for end-users. The web app even allows end-users to create generic tickets with most fields populated, even with no prior system knowledge. This is the opportunity for creativity to be realized. Every now and then, I used to check the logs to see if end-users were creating any tickets without the service desk. This is what makes our profession so engaging and rewarding. The Power of Curiosity I am not entirely sure what initially drew my attention to that new feature, but I am glad it did. My likely thought process would have been, “Ahh! This is cool, but does it have a practical use case? Is it any useful?” And given the new opportunity, I saw the potential. I want to finish my thoughts by saying that whether it is building with Legos or making new software, creativity comes from curiosity, exploration, and asking, “What if?” My nephew’s endless excitement for “creating” reminded me that, at its heart, our job is just as much about play as it is about purpose. We, as developers, can change business ideas into real solutions. We connect what people imagine with what can happen. Every challenge we meet is a chance to create new things, go beyond limits, and change what we think is possible. The tools at our disposal can do so much, just like a child’s art supplies, if only we use them creatively. My nephew’s inventions opened doors to many possibilities. Our ideas and innovations can also help create a brighter and more exciting future. Being curious and open has helped me greatly in my career, and it still does. Today, we are in a time full of possibilities and potential, especially with the advance of artificial intelligence, machine learning, and LLMs. The future looks good, and there are endless opportunities. I wish you a great 2025 and will conclude the article with an inspiring quote from one of the greatest thinkers that ever lived. Imagination is more important than knowledge. For knowledge is limited, whereas imagination encircles the world. – Albert Einstein

By Gaurav Gaur CORE

Process mining is a technique that helps organizations understand, analyze, and improve their processes. This article tries to break it down into simple terms. It explains how process mining can benefit users looking to extract process-level metrics from their applications or tools with minimal data mining background. Key Questions About Process Mining The following questions help get a high-level idea of process mining and whether it’s a good fit for your analytics use case: Why Process Mining? Process mining provides a clear view of how processes run. It extracts data in a straightforward form from systems like ERP or CRM or any event/transition log generated by an application. Why Now? Digital processes are growing and becoming complex with rule-based auto nodes. Identifying end-to-end processes is not easy with many connected systems. Process mining not only discovers processes rapidly for millions of events (in a distributed environment), but it also provides tools to find bottlenecks and highways. Why Data-Driven? Process mining is a bottom-up approach. It discovers the process model from actual event data and provides tools to compare it with the expected process, making it easier to identify deviations. Many BPM system users simply assume that all process instances are compliant and following designed Business process without the need to monitor them. Why Visualize Processes? Visualizing workflows makes it easier for users without a technical background to do the analysis. It’s easier to spot inefficiencies and compliance issues. Long process maps can be cut into smaller ones, and each sub-process can be analyzed separately. Visualization may not fit every use case and automation may be needed to do conformance checking or trigger alerts in case of bottlenecks or anomalies. Why Continuous Improvement? Processes evolve. Process mining makes process owners’ lives easy by providing tools to continuously monitor and improve workflows. Key Elements of Process Mining Process mining has the following core elements: 1. Event Logs Event logs are the input for process mining. Most algorithms expect at least three mandatory fields to discover a process. A unique ID that ties activities occurring at different time stamps. A process model can be discovered if any system is capturing a unique ID, activity name, and time stamp (There are algorithms that require only two mandatory fields). If there are more attributes, then it helps in filtering the data. Example In an order-to-cash process, event logs might capture when an order was placed, processed, and shipped. 2. Process Discovery Process discovery involves creating visual models from event logs. This helps uncover how processes work. Example A manufacturing pipeline can be visualized where each device id passes through a station at a given time. Attributes like Pass/Fail of the device can be aggregated at the variant level to see if any specific variant fails more. 3. Conformance Checking This step compares the actual process (discovered through event logs) with the expected process model. By aggregating the mean or median time for various variants, performance degradation can be identified by continuously monitoring deviations. These deviations can point to compliance issues or areas needing improvement. Example A bank might use conformance checking to ensure loan approvals follow regulatory guidelines. How Process Mining Differs from Data Mining At first glance, process mining and data mining might seem similar because both analyze data. Below are some points that can help decide when to use process mining for a use case: Focus on Processes Data mining identifies patterns or trends in large datasets. For example, it might find a correlation between product sales and customer demographics. Process mining, on the other hand, specifically focuses on workflows and how activities are carried out in sequence. So, it can be used to study a specific demographic and what steps are taken by them before placing an order. A full process journey can also visualize post-order flow, including returns, customer service, etc. Event-Based Approach Process mining uses event logs containing specific timestamps and sequences of activities. Data mining usually evaluates more aggregated data instead of raw events. Goal Data mining aims to predict future outcomes or classify data. Process mining aims to discover, monitor, and optimize processes. Process Mining Algorithms Why can’t we just sequence event logs without using process mining to understand processes? If your use case requires process discovery and analysis, then it’s better to stick to process mining algorithms for the following reasons: Handling Scale Real-world processes involve millions of events. Click events on the website can be in billions. Sequencing activities by simply using time stamps may lead to wrong analysis. Process mining algorithms generate a process model, which is simpler as it removes weak connections. Most of these algorithms can run in a distributed environment. Dealing With Variants Processes don’t always follow a single path. Process mining algorithms generate variants and use those to provide an aggregated view. It also identifies activities that are parallel instead of sequential. Identifying Anomalies Algorithms help discover inefficiencies, loops, and deviations. Auto Discovery Process mining helps generate process models that can be visualized in a simpler form by removing weak edges and activities. It saves time and effort in the analysis of the discovered process. Process Mining Beyond Formal Processes Process mining is not limited to formal business workflows. Any application with event data can be analyzed using this technique. For example, in e-commerce, event logs can reveal customer navigation paths through a website. Different visualizations like Sankey diagrams can map user journeys and help analyze session drop-offs. Sample Event Data Consider the following minimal sample event log: Case IDActivityTimestampResource 1 Submit Order 2024-12-09 09:00:00 User1 1 Process Payment 2024-12-09 09:05:00 User2 1 Ship Order 2024-12-09 10:00:00 User3 2 Submit Order 2024-12-09 09:10:00 User1 2 Process Payment 2024-12-09 09:15:00 User2 2 Quality Check 2024-12-09 09:50:00 User4 2 Ship Order 2024-12-09 11:00:00 User3 Using this data, process mining can: Discover process model: Aggregate all dependencies and generate a simplified process map.Analyze highways and bottlenecks: Identify delays, e.g., longer time between Process Payment and Ship Order in Case 2.Evaluate performance: Slice and dice data by attributes like resources or timestamps to find bottlenecks. One of the most interesting use cases is to find the order of events causing any aggregated metrics to deviate from the normal trend. It’s possible that C->A->A->C->B takes more mean time compared to C->A->C->A->B. In the example above, there are two variants: Submit Order -> Process Payment -> Ship OrderSubmit Order -> Process Payment -> Quality Check -> Ship Order Let’s add another attribute to the event data set – “returned” with a Boolean value. We can aggregate this value at the variant level and compare the two variants to identify if more items get returned when there is no Quality step. This is a very simplified example, but this approach can be used for many complex scenarios where the sequence of activities impacts critical metrics. Identifying Parallel Activities Imagine a customer service process where different teams handle billing and technical issues simultaneously. Without process mining, activities might be linear due to separate variants in event logs. However, a process mining algorithm can: Aggregate multiple variants into a model.Identify patterns where billing and technical activities overlap.Discover the parallel activities in the process map. This insight helps optimize resource allocation. Where to Start With Process Mining? There are open-source libraries and event logs available online to practice process discovery and conformance checking. Below is the list of a few algorithms and their ideal use cases to start with. Directed flow graph: Direct activity sequences.Alpha miner: Simple processes.Heuristic miner: Moderately complex and noisy processes.Inductive miner: Complex logs requiring precise model.Fuzzy miner: Flexible processes requiring a very high-level overview.Clustering-based miner: Varied process logs.Declarative miner: Rule-based processes. Conclusion Process mining, if used properly and implemented correctly for applications at scale, can help provide tools to analyze with visualizations. By discovering actual workflows and checking for conformance, process owners can identify compliance issues. Compared to data mining, process mining uniquely focuses on workflows. Still, it’s important to evaluate each use case properly before picking process mining for analytics, as a lot of traditional use cases can be solved by existing data mining techniques.

Welcome to 2025! A new year is the perfect time to learn new skills or refine existing ones, and for software developers, staying ahead means continuously improving your craft. Software design is not just a cornerstone of creating robust, maintainable, and scalable applications but also vital for your career growth. Mastering software design helps you write code that solves real-world problems effectively, improves collaboration with teammates, and showcases your ability to handle complex systems — a skill highly valued by employers and clients alike. Understanding software design equips you with the tools to: Simplify complexity in your projects, making code easier to understand and maintain.Align your work with business goals, ensuring the success of your projects.Build a reputation as a thoughtful and practical developer prioritizing quality and usability. To help you on your journey, I’ve compiled my top five favorite books on software design. These books will guide you through simplicity, goal-oriented design, clean code, practical testing, and mastering Java. 1. A Philosophy of Software Design This book is my top recommendation for understanding simplicity in code. It dives deep into how to write simple, maintainable software while avoiding unnecessary complexity. It also provides a framework for measuring code complexity with three key aspects: Cognitive Load: How much effort and time are required to understand the code?Change Amplification: How many layers or parts of the system need to be altered to achieve a goal?Unknown Unknowns: What elements of the code or project are unclear or hidden, making changes difficult? The book also discusses the balance between being strategic and tactical in your design decisions. It’s an insightful read that will change the way you think about simplicity and elegance in code. Link: A Philosophy of Software Design 2. Learning Domain-Driven Design: Aligning Software Architecture and Business Strategy Simplicity alone isn’t enough — your code must achieve client or stakeholders' goals. This book helps you bridge the gap between domain experts and your software, ensuring your designs align with business objectives. This is the best place to start if you're new to domain-driven design (DDD). It offers a practical and approachable introduction to DDD concepts, setting the stage for tackling Eric Evans' original work later. Link: Learning Domain-Driven Design 3. Clean Code: A Handbook of Agile Software Craftsmanship Once you’ve mastered simplicity and aligned with client goals, the next step is to ensure your code is clean and readable. This classic book has become a must-read for developers worldwide. From meaningful naming conventions to object-oriented design principles, “Clean Code” provides actionable advice for writing code that’s easy to understand and maintain. Whether new to coding or a seasoned professional, this book will elevate your code quality. Link: Clean Code 4. Effective Software Testing: A Developer’s Guide No software design is complete without testing. Testing should be part of your “definition of done.” This book focuses on writing practical tests that ensure your software meets its goals and maintains high quality. This book covers techniques like test-driven development (TDD) and data-driven testing. It is a comprehensive guide for developers who want to integrate testing seamlessly into their workflows. It’s one of the best software testing resources available today. Link: Effective Software Testing 5. Effective Java (3rd Edition) For Java developers, this book is an essential guide to writing effective and idiomatic Java code. From enums and collections to encapsulation and concurrency, “Effective Java” provides in-depth examples and best practices for crafting elegant and efficient Java programs. Even if you’ve been writing Java for years, you’ll find invaluable insights and tips to refine your skills and adopt modern Java techniques. Link: Effective Java (3rd Edition) Bonus: Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software As a bonus, I highly recommend this book to anyone looking to deepen their understanding of design patterns. In addition to teaching how to use design patterns, this book explains why you need them and how they contribute to building extensible and maintainable software. With its engaging and visually rich style, this book is an excellent resource for developers of any level. It makes complex concepts approachable and practical. Link: Head First Design Patterns These five books and the bonus recommendation provide a roadmap to mastering software design. Whether you’re just starting your journey or looking to deepen your expertise, each offers a unique perspective and practical advice to take your skills to the next level. Happy learning and happy coding! Video

By Otavio Santana CORE

The Forensic Product Backlog Analysis: A 60-minute team exercise to fix your Backlog. Identify what’s broken, find out why, and agree on practical fixes — all in five quick steps. There is no fluff, just results. Want technical excellence and solve customer problems? Start with a solid Product Backlog. A Team Exercise: Forensic Product Backlog Analysis Your Product Backlog is a mission-critical team artifact. It’s not just a list of features or tasks — it reflects your team’s ability to create value for customers and your organization. (You may have heard this before, but we are not paid to practice “Agile” but to solve our customers’ problems within the given constraints while contributing to the organization’s sustainability.) Like any critical system, the “garbage in, garbage out” principle applies: inferior Backlogs lead to inferior products. Here's a structured 60-minute Forensic Product Backlog Analysis that helps teams identify backlog issues and develop practical solutions. The format based on Liberating Structures encourages participation while keeping discussions focused and actionable. Step 1: Individual Anti-Pattern Identification (5 minutes) Each team member identifies five ways to make a Product Backlog low-quality and hamper the team's potential to create value. This silent brainstorming ensures everyone's voice is heard, not just the loudest participants. Take personal notes — you'll need them in the next step. (Learn more about TRIZ.) Step 2: Small Group Analysis (10 minutes) Form groups of 3-4 people. Each group merges their individual findings into a top-five list of Product Backlog anti-patterns. The key here is to rank these patterns from worst to least harmful. This step surfaces the most critical issues while building consensus through small-group discussions. (Learn more about 1-2-4-All.) Step 3: Collective Pattern Recognition (15 minutes) Bring all groups together. The first team presents their ranked list of backlog anti-patterns. Each subsequent team adds their unique findings, creating a merged, ranked list. This step reveals patterns across different perspectives and helps build a comprehensive view of the challenges. (Learn more about White Elephant.) Step 4: Root Cause Analysis (20 minutes) With your consolidated list, analyze each major Product Backlog anti-pattern: What exactly do you observe?What might be causing this pattern?What's one concrete step you could take to address it? This structured forensic Product Backlog analysis prevents the discussion from becoming a complaint session and keeps the focus on actionable insights. (Learn more about 9 Whys.) Step 5: Action Planning (10 minutes) Choose the top three anti-patterns and develop specific countermeasures. The emphasis here is on practical, achievable steps that the team can implement immediately. Remember, small improvements are better than grand plans that never materialize. (Learn more about 15 % Solutions.) Why This Exercise Works The Forensic Product Backlog Analysis exercise works because: It's time-boxed: 60 minutes maintains focus and energyIt's inclusive: Everyone contributes, not just the vocal fewIt's practical: The outcome is a ranked list of actionable improvementsIt's evidence-based: Solutions emerge from observed patterns, not assumptionsIt's team-owned: The group discovers and owns both problems and solutions. The most valuable Product Backlogs emerge from teams regularly examining and improving their practices. This exercise provides a framework for continuous improvement, helping teams move from identifying problems to implementing solutions in a true Kaizen spirit. Final tip: Schedule this session when the team has high energy. The goal is to generate insights leading to improvements, not just create another routine meeting with an action item list no one will ever touch again. Conclusion Start with the Forensic Product Backlog Analysis as outlined, then adapt this exercise to your team's needs. The format is flexible — what matters is the outcome: a clearer understanding of your Product Backlog's health, concrete steps to improve it, and an improved alignment with stakeholders. Remember: A strong Product Backlog is a prerequisite for delivering value. Make time to maintain and improve this critical team asset and invest in your team's reputation and performance — the management and customers will notice.

By Stefan Wolpers CORE

Gantt chart is an advanced visualization solution for project management that considerably facilitates planning, scheduling, and controlling the progress of short-, mid-, and long-term projects. Gantt charts were invented more than a hundred years ago by Henry Gantt, who made a major contribution to the development of scientific management. Decades ago, the entire procedure of implementing Gantt charts in infrastructure projects was really time-consuming. Today, we are lucky to have modern tools that greatly speed up the process. How Does a Gantt Chart Make Project Planning Easier? To make the entire process of project management easier to deal with, a Gantt chart takes care of all the complex logic and provides users with a convenient interface to handle process-related data. Thus, a Gantt chart basically has two sections: the left one with a list of tasks and subtasks and the right one with the visualized project timeline. This helps represent the whole set of interdependent tasks in a more digestible way. In this article, we are going to take a closer look at Gantt chart libraries for React that provide rich functionality, allowing us to efficiently manage really complex business processes. We do not set the goal of considering comprehensive lists of features for each of the tools, but want to focus on some interesting points characterizing the libraries we have chosen. SVAR React Gantt Chart SVAR React Gantt Chart is a free, open-source solution available under the GPLv3 license. This Gantt chart library offers an appealing UI and supplies users with advanced features for supervising tasks within a project. Key features: Create, edit, and delete tasks with sidebar form,Modify tasks and dependencies directly on the chart with drag-and-drop,Reorder tasks in the grid with drag-and-drop,Task dependencies: end-to-start, start-to-start, end-to-end, start-to-end,Hierarchical view of sub-tasks,Sorting by a single or multiple columns,Fully customizable task bars, tooltips, time scale,Toolbar and context menu,High performance with large data sets,Light and dark themes. The list represented above is not exhaustive, as the SVAR Gantt Chart equips users with many other convenient functionalities, like zooming, flexible or fixed grid columns, touch support, etc. This open-source library offers a wide range of features and is able to cope with complex business tasks. Check the demos to see what the SVAR Gantt Chart is capable of. DHTMLX Gantt for React DHTMLX Gant for React is a versatile solution that offers an easy way to add a feature-rich Gantt chart to a React-based application. It is distributed as a stand-alone component with flexible licensing options, prices starting from $699, and a free 30-day trial. Key features: Smooth performance with high working loads (30 000+ tasks)Dynamic loading and smart renderingPredefined and custom types of tasksFlexible time formattingAdditional timeline elements (milestones, baselines, deadlines, constraints)Project summaries with rollup tasksAdvanced features (resource management, auto-scheduling, critical path, task grouping, etc.)Accessibility and localizationExport to PDF/PNG/MS Project7 built-in skinsSimplified styling with CSS variables The extensive and developer-friendly API of this UI component allows dev teams to create React Gantt charts to manage workflows of any scale and complexity. There are plenty of configuration and customization options to meet any specific project requirements. Syncfusion React Gantt Chart Syncfusion React Gantt Chart is a task scheduling component for monitoring tasks and resources. It is part of Syncfusion Essential Studio that comes under a commercial Team License (starting from $395 per month) or a free community license, which is available under strict conditions. Key features: Configurable timeline,Full support of CRUD operation,Drag-and-drop UI,Built-in themes,Critical path support (well-suited for projects with fixed deadlines),The possibility to split and merge tasks,Resource view,Context menu and Excel-like filters,Undo/redo capabilities for reverting/reapplying actions,Virtual scrolling for large data sets,The possibility to highlight events and days. This React Gantt chart component is really feature-rich and well-suited for managing complex processes and resource allocation, although its pricing policy can be considered aggressive, and some users have noted challenges when attempting advanced customizations to fit specific needs. Kendo React Gantt Chart Kendo React Gantt Chart is a performant and customizable tool for handling large projects, which is a part of the KendoUI library. The UI component is available under a commercial license of $749 per developer with a free trial version. Key features: Tasks sorting (by task type or task start date);Filtering, including conditional filtering that can be configured;Easy data binding (a helper method converts flat data into a more complex data structure required by the Gantt chart);Task dependencies: end-to-start, start-to-start, end-to-end, start-to-end,Task editing via popup form;Customizable time slots;Time zones support,Day, week, month, year views. To sum up, we can say that along with basic features for project management, this UI component has a lot to offer for building sophisticated business apps. However, it lacks the interactivity of the drag-and-drop interface found in the tools mentioned above. DevExtreme React Gantt DevExtreme React Gantt is a configurable UI Gantt component for the fast development of React-based task management applications. This solution is distributed within the DevExtreme Complete package under the commercial license (starting from $900 per developer). A free trial is available. Key features: Move and modify tasks on the chart with drag-and-drop,Data sorting by a single or multiple columns,Column filtering and header filters with a pop-up menu,Validation of task dependencies,Export of data to PDF,Task templates that allow customizing task elements,Toolbars and a context menu for tasks,Tooltips support,Strip lines for highlighting specific time or a time interval. As you can see, the component contains a list of features that can be of interest in case you are looking for a multifunctional project management tool, just test them to check whether they are well-suited for your particular purposes. Smart React UI Gantt Chart Smart React UI Gantt Chart is one more React component that helps you add a project planning and management solution to your apps. This tool is distributed as a part of the “Smart UI” package under commercial licenses. The pricing starts from $399 per developer. Key features: Task editing via popup edit form,Move and modify tasks on the chart with drag-and-drop,Assign resources to tasks (timeline and diagram/histogram);Task dependencies;Filtering and sorting of tasks and resources;Tasks auto rescheduling;Built-in themes (7 in total);Export of data in different formats (PDF, Excel, TSV, CSV);Task tooltips and indicators;Localization, RTL. Smart React UI Gantt Chart contains all necessary capabilities for carrying out the management of complex projects. It offers powerful features like task auto-rescheduling and built-in themes, making it a flexible option for various project management needs. Conclusion In this article, we've explored several Gantt chart libraries for React, each offering unique capabilities for project management visualization. These solutions range from commercial offerings with extensive enterprise features to open-source alternatives. While commercial solutions like Syncfusion, DHTMLX, Kendo, DevExtreme, and Smart React UI offer comprehensive feature sets with professional support, the open-source SVAR React Gantt stands out with its free license, making it a compelling option for developers seeking a robust solution without licensing costs. When considering these libraries, check whether they fully meet your requirements in terms of the feature set, documentation and support, performance, seamless integration, data binding, and customization options. Take time to evaluate each solution against your specific project requirements to find the best fit for your development needs.

GenAI Logic using ApiLogicServer has recently introduced a workflow integration using the n8n.io. The tool has over 250 existing integrations and the developer community supplies prebuilt solutions called templates (over 1000) including AI integrations to build chatbots. GenAI Logic can build the API transaction framework from a prompt and use natural language rules (and rule suggestions) to help get the user started on a complete system. Eventually, most systems require additional tooling to support features like email, push notifications, payment systems, or integration into corporate data stores. While ApiLogicServer is an existing API platform, writing 250 integration endpoints with all the nuances of security, transformations, logging, and monitoring — not to mention the user interface — would require a huge community effort. ApiLogicServer found the solution with n8n.io (one of many workflow engines on the market). What stands out is that n8n.io offers a community version using a native Node.js solution for local testing (npx n8n) as well as a hosted cloud version. N8N Workflow In n8n, you create a Webhook from ApiLogicServer object which creates a URL that can accept an HTTP GET, POST, PUT, or DELETE, with added basic authentication (user: admin, password: p) to test the webhook. The Convert to JSON block provides a transformation of the body (a string) into a JSON object using JavaScript. The Switch block allows routing based on different JSON payloads. The If Inserted block decides if the Employee was an insert or update (which is passed in the header). The SendGrid blocks register a SendGrid API key and format an email to send (selecting the email from the JSON using drag-n-drop). Finally, the Respond to Webhook returns a status code of 200 to the ApiLogicServer event. Employees, Customers, and Orders are all sent to the same Webhook Configuration There are two parts to the configuration. The first is the installation of the workflow engine n8n.io (either on-premise, Docker, or cloud), and then the creation of the webhook object in the workflow diagram (http://localhost:5678). This will generate a unique name and path that is passed to the ApiLogicServer project in the config/config.py directory; in this example, a simple basic authorization (user/password). Note: In an ApiLogicServer project integration/n8n folder, this sample JSON file is available to import this example into your own n8n project! Webhook Output ApiLogicServer Logic and Webhook The real power of this is the ability to add a business logic rule to trigger the webhook, adding some configuration information (n8n server, port, key, and path plus authorization). So the actual rule (after_flush_row_event) is called anytime an insert event occurs on an API endpoint. The actual implementation is simply a call to the Python code to post the payload (e.g., requests.post(url=n8n_webhook_url, json=payload, headers=headers)). Configuration to call n8n webhook config/config.py: Python wh_scheme = "http" wh_server = "localhost" # or cloud.n8n.io... wh_port = 5678 wh_endpoint = "webhook-test" # from n8n Webhook URL wh_path = "002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69" # from n8n Webhook URL token = "YWRtaW46cA==" #base64 encode of user/pasword admin:p N8N_PRODUCER = {"authorization": f"Basic {token}", "n8n_url": \ f'"{wh_scheme}://{wh_server}:{wh_port}/{wh_endpoint}/{wh_path}"'} # Or enter the n8n_url directly: N8N_PRODUCER = {"authorization": f"Basic \ {token}","n8n_url":"http://localhost:5678/webhook-test/002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69"} #N8N_PRODUCER = None # comment out to enable N8N producer Call a business rule (after_flush_row_event) on the API entity: Python def call_n8n_workflow(row: Employee, old_row: Employee, logic_row: LogicRow): """ Webhook Workflow: When Employee is inserted = post to n8n webhook """ if logic_row.is_inserted(): status = send_n8n_message(logic_row=logic_row) logic_row.log(status) Rule.after_flush_row_event(on_class=models.Emploee, calling=call_n8n_workflow) Declarative Logic (Rules) ApiLogicServer is an open-source platform based on SQLAlchemy ORM and Flask. The SQLAlchemy provides a hook (before flush) that allows LogicBank (another open-source tool) to let developers declare "rules." These rules fall into 3 categories: derivations, constraints, and events. Derivations are similar to spreadsheet rules in that they operate on a selected column (cell): formula, sums, counts, and copy. Constraints operate on the API entity to validate the row and will roll back a multi-table event if the constraint test does not pass. Finally, the events (early, row, commit, and flush) allow the developer to call "user-defined functions" to execute code during the lifecycle of the API entity. The WebGenAI feature (a chatbot to build applications) was trained on these rules to use natural language prompts (this can also be done in the IDE using Copilot). Notice that the rules are declared and unordered. New rules can be added or changed and are not actually processed until the state change of the API or attribute is detected. Further, these rules can impact other API endpoints (e.g., sums, counts, or formula) which in turn can trigger constraints and events. Declarative rules can easily be 40x more concise than code. Natural language rules generated by WebGenAI: Python Use LogicBank to enforce the Check Credit requirement: 1. The Customer's balance is less than the credit limit 2. The Customer's balance is the sum of the Order amount_total where date_shipped is null 3. The Order's amount_total is the sum of the Item amount 4. The Item amount is the quantity * unit_price 5. The Item unit_price is copied from the Product unit_price Becomes these Rules logic/declary_logic.py #ApiLogicServer: basic rules - 5 rules vs 200 lines of code: # logic design translates directly into rules Rule.constraint(validate=Customer, as_condition=lambda row: row.Balance <= row.CreditLimit, error_msg="balance ({round(row.Balance, 2)}) exceeds credit ({round(row.CreditLimit, 2)})") # adjust iff AmountTotal or ShippedDate or CustomerID changes Rule.sum(derive=Customer.Balance, as_sum_of=Order.AmountTotal, where=lambda row: row.ShippedDate is None and row.Ready == True) # adjust iff Amount or OrderID changes Rule.sum(derive=Order.AmountTotal, as_sum_of=OrderDetail.Amount) Rule.formula(derive=OrderDetail.Amount, as_expression=lambda row: row.UnitPrice * row.Quantity) # get Product Price (e,g., on insert, or ProductId change) Rule.copy(derive=OrderDetail.UnitPrice,from_parent=Product.UnitPrice) SendGrid Email N8N has hundreds of integration features that follow the same pattern. Add a node to your diagram and attach the input, configure the settings (here, a SendGrid API key is added), and test to see the output. The SendGrid will respond with a messageId (which can be returned to the caller or stored in a database or Google sheet). Workflows can be downloaded and stored in GitHub or uploaded into the cloud version. SendGrid input and output (use drag and drop to build email message) AI Integration: A Chatbot Example The community contributes workflow "templates" that anyone can pick up and use in their own workflow. One template has the ability to take documents from S3 and feed them to Pinecone (a vector data store). Then, use the AI block to link this to ChatGPT — the template even provides the code to insert into your webpage to make this a seamless end-to-end chatbot integration. Imagine taking your product documentation in Markdown and trying this out on a new website to help users understand how to chat and get answers to questions. AI workflow to build a chatbot Summary GenAI Logic is the new kid on the block. It combines the power of AI chat, natural language rules, and API automation framework to instantly deliver running applications. The source is easily downloaded into a local IDE and the work for the dev team begins. With the API in place, the UI/UX team can use the Ontimze (Angular) framework to "polish" the front end. The developer team can add logic and security to handle the business requirements. Finally, the integration team can build the workflows to meet the business use case requirements. ApiLogicServer has a Kafka integration for producers and consumers. This extends the need for real-time workflow integration and can produce a Kafka message that a consumer can start the workflow (and log, track, and retry if needed). N8N provides an integration space that gives ApiLogicServer new tools to meet most system integration needs. I have also tested Zapier webhook (a cloud-based solution) which works the same way. Try the WebGenAI for free to get started building apps and logic from prompts.

Configuration files control how applications, systems, and security policies work, making them crucial for keeping systems reliable and secure. If these files are changed accidentally or without permission, it can cause system failures, security risks, or compliance issues. Manually checking configuration files takes a lot of time, is prone to mistakes, and isn’t reliable, especially in complex IT systems. Event-driven Ansible offers a way to automatically monitor and manage configuration files. It reacts to changes as they happen, quickly detects them, takes automated actions, and works seamlessly with the tools and systems you already use. In this article, I will demonstrate how to use Ansible to monitor the Nginx configuration file and trigger specific actions if the file is modified. In the example below, I use the Ansible debug module to print the message to the host. However, this setup can be integrated with various Ansible modules depending on the organization's requirements. About the Module The ansible.eda.file_watch module is a part of event-driven Ansible and is used to monitor changes in specified files or directories. It can detect events such as file creation, modification, or deletion and trigger automated workflows based on predefined rules. This module is particularly useful for tasks like configuration file monitoring and ensuring real-time responses to critical file changes. Step 1 To install Nginx on macOS using Homebrew, run the command brew install nginx, which will automatically download and install Nginx along with its dependencies. By default, Homebrew places Nginx in the directory /usr/local/Cellar/nginx/ and configures it for use on macOS systems. After installation, edit the configuration file at /usr/local/etc/nginx/nginx.conf to set the listen directive to listen 8080;, then start the Nginx service with brew services start nginx. To confirm that Nginx is running, execute the command curl http://localhost:8080/ in the terminal. If Nginx is properly configured, you will receive an HTTP response indicating that it is successfully serving content on port 8080. Step 2 In the example below, the configwatch.yml playbook is used to monitor the Nginx configuration file at /usr/local/etc/nginx/nginx.conf. It continuously observes the file for any changes. When a modification is detected, the rule triggers an event that executes the print-console-message.yaml playbook. YAML --- - name: Check if the nginx config file is modified hosts: localhost sources: - name: file_watch ansible.eda.file_watch: path: /usr/local/etc/nginx/nginx.conf recursive: true rules: - name: Run the action if the /usr/local/etc/nginx/nginx.conf is modified condition: event.change == "modified" action: run_playbook: name: print-console-message.yml This second playbook performs a task to print a debug message to the console. Together, these playbooks provide automated monitoring and instant feedback whenever the configuration file is altered. YAML --- - name: Playbook for printing the message in console hosts: localhost connection: local gather_facts: false tasks: - name: Error message in the console debug: msg: "Server config altered" Demo To monitor the Nginx configuration file for changes, execute the command ansible-rulebook -i localhost -r configwatch.yml, where -i localhost specifies the inventory as the local system, and -r configwatch.yml points to the rulebook file that defines the monitoring rules and actions. This command will initiate the monitoring process, enabling Ansible to continuously watch the specified Nginx configuration file for any modifications. When changes are detected, the rules in the configwatch.yml file will trigger the action to run the print-console-message.yaml playbook. Check the last modified time of /usr/local/etc/nginx/nginx.conf by running the ls command. Use the touch command to update the last modified timestamp, followed by the ls command to display the output in the console. The output of the ansible-rulebook -i localhost -r configwatch.yml command, it detected the file timestamp modification change and triggered the corresponding action. Benefits of Event-Driven Ansible for Configuration Monitoring Event-driven Ansible simplifies configuration monitoring by instantly detecting changes and responding immediately. Organizations can extend the functionality to automatically fix issues without manual intervention, enhancing security by preventing unauthorized modifications. It also supports compliance by maintaining records and adhering to regulations while efficiently managing large and complex environments. Use Cases The Event-Driven Ansible File Watch module can serve as a security compliance tool by monitoring critical configuration files, such as SSH or firewall settings, to ensure they align with organizational policies. It can also act as a disaster recovery solution, automatically restoring corrupted or deleted configuration files from predefined backups. Additionally, it can be used as a multi-environment management tool, ensuring consistency across deployments by synchronizing configurations. Conclusion Event-driven Ansible is a reliable and flexible tool for monitoring configuration files in real time. It automatically detects, helping organizations keep systems secure and compliant. As systems become more complex, it offers a modern and easy-to-adapt way to manage configurations effectively. Note: The views expressed on this blog are my own and do not necessarily reflect the views of Oracle.

Database administrators play a crucial role in our organizations. They manage databases, monitor performance, and address issues as they arise. However, consider the possibility that their current role may be problematic and that we need to rethink how they operate and integrate within our organizations. Successful companies do not have DBAs. Continue reading to find out why. DBAs Make Teamwork Harder One of the problems with having a separate team of DBAs is that it can unintentionally push other teams into silos and kill all the teamwork. Let's explore why this happens. DBAs need to stay informed about all activities in the databases. They need to be aware of every change, modification, and system restart. This requirement clashes with how developers prefer to deploy their software. Developers typically want to push their code to the repository and move on, relying on CI/CD pipelines to handle tests, migrations, deployments, and verifications. These pipelines can take hours to complete, and developers don't want to be bogged down by them. However, this approach doesn't align well with how DBAs prefer to work. DBAs need to be aware of changes and when they occur within the system. This necessitates team synchronization, as DBAs must be involved in the deployment process. Once DBAs are involved, they often take control, leading developers to feel less responsible. This dynamic causes teams to become siloed. Developers feel less responsible, while DBAs take on more control. Over time, developers begin to offload responsibilities onto the DBAs. Knowing they need to coordinate with DBAs for any database changes, developers come to expect DBAs to handle them. This creates a vicious cycle where developers become less involved, and DBAs assume more responsibility, eventually leading to a status quo where developers do even less. This situation is detrimental to everyone. Developers feel less accountable, leading to reduced involvement and engagement. DBAs become frustrated with their increased workload. Ultimately, the entire organization wastes time and resources. Successful companies tend to move towards greater teamwork and faster development, so they limit the scope of DBAs and let them focus on architectural problems. Teams Do Not Develop Their Skills Another consequence of having dedicated DBAs is that developers stop learning. The most effective way to learn is through hands-on experience, which enables teams to make significant progress quickly. With DBAs available, developers often rely on them for help. While it's beneficial if they learn from this interaction, more often, developers shift responsibilities to the DBAs. As a result, developers stop learning, and databases become increasingly unfamiliar territory. Instead, we should encourage developers to gain a deeper understanding and practical experience with databases. To achieve this, developers need to take on the responsibility of maintaining and operating the databases themselves. This goal is difficult to reach when there is a separate team of DBAs accountable for managing database systems. Teams Overcommunicate When DBAs are held accountable and developers take on less responsibility, organizations end up wasting more time. Every process requires the involvement of both teams. Since team cooperation can't be automated with CI/CD, more meetings and formal communications through tickets or issues become necessary. This significantly degrades performance. Each time teams need to comment on issues, they spend valuable time explaining the work instead of doing it. Even worse, they have to wait for responses from the other team, causing delays of hours. When different time zones are involved, entire days of work can be lost. Successful Companies Have a Different Approach The best companies take a different approach. All these issues can be easily addressed with database guardrails. These tools integrate with developers' environments and assess database performance as developers write code. This greatly reduces the risk of performance degradation, data loss, or other issues with the production database after deployment. Additionally, database guardrails can automate most DBA tasks. They can tune indexes, analyze schemas, detect anomalies, and even use AI to submit code fixes automatically. This frees DBAs from routine maintenance tasks. Without needing to control every aspect of the database, DBAs don't have to be involved in the CI/CD process, allowing developers to automate their deployments once again. Moreover, developers won't need to seek DBA assistance for every issue, as database guardrails can handle performance assessments. This reduces communication overhead and streamlines team workflows. What Is the Future of DBAs? DBAs possess extensive knowledge and hands-on experience, enabling them to solve the most complex issues. With database guardrails in place, DBAs can shift their focus to architecture, the big picture, and the long-term strategy of the organization. Database guardrails won't render DBAs obsolete; instead, they will allow DBAs to excel and elevate the organization to new heights. This means no more tedious day-to-day maintenance, freeing DBAs to contribute to more strategic initiatives. Summary The traditional approach to using DBAs leads to inefficiencies within organizations. Teams become siloed, over-communicate, and waste time waiting for responses. Developers lose a sense of responsibility and miss out on learning opportunities, while DBAs are overwhelmed with daily tasks. Successful organizations let DBAs work on higher-level projects and release them from the day-to-day work.

By Adam Furmanek CORE

TL; DR: Three Data Points Pointing to the Decline of the Scrum Master’s Role If you hang out in the “Agile” bubble on LinkedIn, the dice have already been cast: Scrum is out (and the Scrum Master), and the new kid on the block is [insert your preferred successor framework choice here.] I’m not entirely certain about that, but several data points on my side suggest a decline in the role of the Scrum Master. Read on and learn more about whether the Scrum Master is a role at risk. My Data Points: Downloads, Survey Participants, Scrum Master Class Students Here are my three data points regarding the development: Decline in Download Numbers of the Scrum Master Interview Questions Guide Years ago, I created the Scrum Master Interviews Question Guide on behalf of a client to identify suitable candidates for open Scrum Master positions. It has since grown to 83 questions and has been downloaded over 28,000 times. Interestingly, the number of downloads in 2022 (2,428) and 2024 (1,236) practically halved. I would have expected the opposite, with newly unemployed Scrum Masters preparing for new rounds of job interviews. Unless, of course, the number of open positions also drops significantly, and fewer candidates need to brush up their Scrum knowledge before an interview. Decline in the Number of Participants in the Scrum Master Salary Report Since 2017, I have published the Scrum Master Salary Report more or less regularly. The statistical model behind the survey is built on a threshold of 1,000 participants, as the survey addresses a global audience. It has never been easy to convince so many people to spend 10 minutes supporting a community effort, but I have managed so far. For the 2024 edition, we had 1,114 participants. In 2023, we had 1,146 participants; in 2022, there were 1,113. But this time, it is different. Before an emergency newsletter on December 26, 2024, there were fewer than 400 valid data sets; today, there are still fewer than 650. (There likely won’t be a 2025 edition.) Decline in Scrum Master Class Students As a Professional Scrum Trainer, I run an educational business that offers Scrum.org-affiliated classes, such as those for Scrum Masters. In 2020, the entry-level Scrum Master classes — public and private — represented 49% of my students. In 2021, that number dropped to 26%, but I also offered more different classes. In 2022, the number was stable at 24%, and it fell to 17% in 2023. In 2024, however, that number was less than 5%, and I decided to stop offering these classes as public offerings altogether in 2025. Are those student numbers representative? Of course not. However, they still point to the declining perception of how valuable these classes are from the career perspectives of individuals and corporate training departments. (By the way, the corresponding Product Owner classes fare much better.) Conclusion Of course, in addition to those mentioned above, there are other indicators: Google trends for the search term “Scrum Master,” the number of certifications passed, or job openings on large job sites. Nevertheless, while the jury is still out, it seems that many organizations' love affair with the Scrum Master role has cooled significantly. What is your take: is the Scrum Master a role in decline? Please share your observations with us via the comments.

By Stefan Wolpers CORE