If we build and release an app, and we notice that the performance is sluggish, we should profile that app and benchmark its performance. It's akin to doing an x-ray on a patient, plus maybe doing some lab analysis (blood, urine, whathaveyou). That practice should help us identify the bottleneck(s). In my experience, most of the time the culprit for suboptimal performance is found at the I/O boundary. That bottleneck is relatively easy to identify. Once identified, the team should work on removing the bottleneck. But if the team hasn't identified the bottleneck, there is a risk of them wasting time, money, and effort on optimizing imaginary bottlenecks. Most typically, from what I see, teams may jump on working on optimizing the code, tightening the performance of the code that runs in main memory. What a waste! No matter how much we improve the performance of the code, the app will remain as sluggish as it was before we wasted so much time, money, and effort on trying to fix it. The real bottleneck is still there. Similar considerations apply to the team's work style. If the delivery to production is sluggish, no use trying to invent ways for the team to write the code faster, unless we have proven that the bottleneck is indeed in the speed of typing. But I see teams arguing against some new ways of working (mob programming, for example) saying that it is slowing the rate of pumping code into the feature branch. Even if that were true, who cares? Just bloating the feature branch with more and more code is the exact opposite of productivity. Do teams realize that productivity only means putting solutions in the hands of end users/customers? So, where is the real bottleneck that is causing teams to falter and delay the production of solutions? I'd wager to say it's never in the speed of writing the code.
Alex Bunardzic’s Post
More Relevant Posts
-
Immediate joiner| Front end developer | React.Js Developer | Html | Css | JavaScript| | Tailwind CSS | GitHub| Web development
🚀 Struggling to Manage State in Your App? 🤔 Hey developers! 👋 As your app evolves and grows, keeping track of all that precious data can feel like herding cats 🐱. We get it! Managing state is no small feat, but fear not, you're not alone in this challenge. Whether you're wrestling with sprawling data structures or battling to keep your app's behavior consistent, we've all been there. But hey, that's where the magic of problem-solving kicks in! 💡 Here are a few tips to help you stay on top of your state game: 1️⃣ **Centralize Your State**: Consider consolidating your state into a single, well-organized source. This can make it easier to understand and control how your data flows. 2️⃣ **Immutable Data**: Embrace immutability! By treating your data as unchangeable, you can prevent unexpected side effects and make debugging a breeze. 3️⃣ **State Management Libraries**: Don't reinvent the wheel! Explore the plethora of state management libraries out there, like Redux or MobX, to streamline your workflow. 4️⃣ **Debugging Tools**: Invest in tools that help you visualize and debug your state changes. A little insight can go a long way in unraveling those tricky bugs. 5️⃣ **Documentation**: Document, document, document! Keeping thorough documentation of your state structure and changes can save you from headaches down the road. Remember, Rome wasn't built in a day, and neither is flawless state management. Keep experimenting, keep learning, and most importantly, keep coding! 💻✨ How do you handle state management in your apps? Share your insights below! 👇 #StateManagement #DeveloperLife #CodingTips #TechTalks
-
-
📣 𝗬𝗼𝘂𝗿 𝗧𝗼-𝗗𝗼'𝘀 𝘄𝗶𝘁𝗵 𝗮 𝗖𝗿𝗼𝘀𝘀-𝗣𝗹𝗮𝘁𝗳𝗼𝗿𝗺 𝗔𝗽𝗽: I recently tackled the challenge of building a cross-platform to-do list app using wxWidgets and C++ . This project empowered me to streamline my tasks with intuitive features like 𝙖𝙙𝙙𝙞𝙣𝙜 𝘪𝘵𝘦𝘮𝘴, 𝘰𝘯𝘦-𝘤𝘭𝘪𝘤𝘬 𝙙𝙚𝙡𝙚𝙩𝙞𝙤𝙣 ️, priority 𝙨𝙤𝙧𝙩𝙞𝙣𝙜 by arrow keys (⬆️⬇️), and persistence 𝙖𝙘𝙧𝙤𝙨𝙨 𝙥𝙧𝙤𝙜𝙧𝙖𝙢 sessions. Building this app was a rewarding journey that deepened my understanding of wxWidgets and C++ . Here are some 𝗞𝗲𝘆 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝘀 I'd like to share: 𝟭. 𝗖𝗵𝗼𝗼𝘀𝗶𝗻𝗴 𝘁𝗵𝗲 𝗥𝗶𝗴𝗵𝘁 𝗧𝗼𝗼𝗹𝘀: I utilized components like wxFrame for the main window, wxTextCtrl for task entry, and wxListCtrl for 𝘥𝘪𝘴𝘱𝘭𝘢𝘺𝘪𝘯𝘨 𝘢𝘯𝘥 𝘮𝘢𝘯𝘢𝘨𝘪𝘯𝘨 𝘵𝘢𝘴𝘬𝘴 (think checklist! ✅). Event handling became crucial, allowing me to capture user actions like 𝘢𝘥𝘥𝘪𝘯𝘨 𝘵𝘢𝘴𝘬𝘴 (button click) , selecting tasks for 𝘱𝘳𝘪𝘰𝘳𝘪𝘵𝘺 𝘴𝘰𝘳𝘵𝘪𝘯𝘨 (moving items up or down), and 𝘥𝘦𝘭𝘦𝘵𝘪𝘯𝘨 𝘵𝘢𝘴𝘬𝘴❌. 𝟮. 𝗗𝗮𝘁𝗮 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 𝗮𝗻𝗱 𝗣𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝗲: Selecting the right data structure was essential. I opted for an array with resizing to handle task insertion, deletion, and priority updates efficiently. The ability to save and load tasks was achieved through text files. This ensures your to-do list stays with you even after closing the app.📑 𝟯. 𝗖𝗼𝗻𝗾𝘂𝗲𝗿𝗶𝗻𝗴 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲𝘀 𝗮𝗻𝗱 𝗕𝗲𝘀𝘁 𝗣𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀: Development wasn't without hurdles, like debugging UI issues and handling complex user interactions. However, this experience highlighted the importance of following best practices like well-structured code and clear documentation to maintain code integrity and future-proof the application.🔁 This project was a valuable exercise in wxWidgets, C++, and desktop app development. Feel free to connect with me to discuss the app, share your experiences with wxWidgets or to-do list apps, or suggest ways to make it even better! Let's keep those to-dos conquered! CodeAlpha #todos #codealpha #ai #data #ML #C++ #wxwidgets #desktopapp
-
Technical Cofounder / Freelancer / Solopreneur | Turning Ideas into Reality | Code & No-Code | Let's Build Something Amazing!
Very recently published a post on a simple method to integrate Typeform and Glide. If you are into #nocode , you may find it interesting and useful! If you are a SMB trying to automate multiple processes, you may be intrigued 😁 Check it out! https://lnkd.in/gQH_XNR9 #nocodedevelopment #smbgrowth
-
Experienced Frontend Developer | React, HTML, CSS, JavaScript, Next.js, React Native , Angular, NodeJs, SEO, Docker, CI/CD , Voice Over Artist , Prompt Engineering Specialist
🚀 State Management Demystified: How It Works Behind the Scenes 🛠️ Ever wondered how state management works under the hood? Let's dive into the magic ✨ of state management in your favorite applications! 🌟 🧠 Understanding State Management: State management is the backbone of any application, ensuring data integrity and seamless user experiences. It involves managing the state (or data) of your application and updating it dynamically as users interact with it. 🔄 Dynamic Updates: When a user interacts with your app—whether it's clicking a button, filling out a form, or navigating to a different page—the application's state changes. State management libraries, like Redux or React Context, handle these changes efficiently, updating the UI to reflect the new state. 💡 Example: Redux in Action: Consider a shopping cart feature in an e-commerce app. As users add items to their cart, the state of the cart (such as the list of items and the total price) changes. Redux, a popular state management library for React, manages this state seamlessly, ensuring that the UI always reflects the latest cart state. 🔍 Behind the Scenes: Under the hood, state management libraries use concepts like immutability and reducers to update state in a predictable and efficient manner. They provide a centralized store where all application data resides, making it easy to access and modify state from anywhere in your app. Let's empower developers worldwide with the knowledge of state management! 💪✨ #StateManagement #ReactJS #Redux #FrontendDevelopment #ApplicationDevelopment #TechTips #DeveloperCommunity #CodeNewbie #LearnToCode #Programming #TechCommunity #StateManagement101 #DeepakCodeWaves #ReactRedux #DeveloperLife #LearnProgramming #CodeWithConfidence 🚀🌎
-
Idea to software, fast
From Idea to Web App in Under an Hour 🚀 At our company, we constantly need to manage everyone's hours since we're in the software service industry. I've always been a fan of building software but never had the opportunity to dive in and create something myself. So, I thought, why not build something for my own use case? Recently, I was introduced to Claude by Anthropic and decided to give it a try through prompt engineering over the weekend. I was able to create an app in less than an hour and even deploy it on Replit, making it accessible on a website. Check out the brief simulation below. Though, I hadn't connected it with any database yet but the results were still fascinating. The gap between idea and implementation is shrinking fast. It’s not just changing how we work—it’s changing who gets to create. The divide between dreaming and doing has never felt smaller. I realized that AI isn't just changing how we work; it’s redefining who has the power to create. One thing is clear: The future of software development is here, and it’s for everyone!
-
I’ve just published a new article on building a RAG (Retrieval-Augmented Generation) app using Marblism. If you’re interested in AI-driven software development, this guide offers a straightforward approach to quickly launching your next project. Read it here: https://lnkd.in/dm9pHyB6
Building a RAG App on Marblism
medium.com
-
Outsystems Certified Web/Reactive/Mobile developer | Full-Stack Web Developer | Certified Scrum Master | PostgreSQL, MySQL Specialist | Java developer
Just sharing about the 12 Factor App methodology! If you're into modern software development and building scalable, maintainable apps, you've got to check out this comprehensive guide outlining best practices for building cloud-native applications. From codebase to dependencies and configurations to scaling. #SoftwareDevelopment #12FactorApp #CloudNative #TechInnovation
The Twelve-Factor App
12factor.net
-
Build Internal Tools & Custom Apps in Minutes: Frontly Takes No-Code to the Next Level Struggling to develop internal tools and custom applications for your business needs? Frontly.ai steps in as your revolutionary no-code platform, empowering you to build powerful applications without writing a single line of code. Frontly.ai empowers you with: * Effortless App Creation: Drag-and-drop interface and pre-built components make app development intuitive and accessible. * Seamless Data Integration: Connect your applications to existing data sources for streamlined workflows. * Flexible User Management: Control access and functionality based on user roles and permissions. * Scalable Solutions: Build applications that grow with your business needs. Benefits for Businesses: * Reduced Development Costs: Bypass expensive coding projects and get your applications up and running faster. * Empower Your Team: Enable non-technical users to contribute to application development. * Increased Efficiency: Streamline internal processes and automate repetitive tasks with custom-built tools. Ready to unlock the power of no-code app development? Visit https://lnkd.in/ePtzT6sk and see how Frontly.ai can revolutionize your internal workflows today! Frontly.ai: Where Innovation Meets Simplicity. #NoCode #AppDevelopment #InternalTools #FrontlyAI #BusinessAutomation
Frontly
benchmark.is
-
The helidon microservice also follows these
Have you heard of the 12-Factor App? The "12 Factor App" offers a set of best practices for building modern software applications. Following these 12 principles can help developers and teams in building reliable, scalable, and manageable applications. Here's a brief overview of each principle: 1. Codebase: Have one place to keep all your code, and manage it using version control like Git. 2. Dependencies: List all the things your app needs to work properly, and make sure they're easy to install. 3. Config: Keep important settings like database credentials separate from your code, so you can change them without rewriting code. 4. Backing Services: Use other services (like databases or payment processors) as separate components that your app connects to. 5. Build, Release, Run: Make a clear distinction between preparing your app, releasing it, and running it in production. 6. Processes: Design your app so that each part doesn't rely on a specific computer or memory. It's like making LEGO blocks that fit together. 7. Port Binding: Let your app be accessible through a network port, and make sure it doesn't store critical information on a single computer. 8. Concurrency: Make your app able to handle more work by adding more copies of the same thing, like hiring more workers for a busy restaurant. 9. Disposability: Your app should start quickly and shut down gracefully, like turning off a light switch instead of yanking out the power cord. 10. Dev/Prod Parity: Ensure that what you use for developing your app is very similar to what you use in production, to avoid surprises. 11. Logs: Keep a record of what happens in your app so you can understand and fix issues, like a diary for your software. 12. Admin Processes: Run special tasks separately from your app, like doing maintenance work in a workshop instead of on the factory floor. Over to you: Where do you think these principles can have the most impact in improving software development practices? -- Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq #systemdesign #coding #interviewtips .
-
-
Have you heard of the 12-Factor App? The "12 Factor App" offers a set of best practices for building modern software applications. Following these 12 principles can help developers and teams in building reliable, scalable, and manageable applications. Here's a brief overview of each principle: 1. Codebase: Have one place to keep all your code, and manage it using version control like Git. 2. Dependencies: List all the things your app needs to work properly, and make sure they're easy to install. 3. Config: Keep important settings like database credentials separate from your code, so you can change them without rewriting code. 4. Backing Services: Use other services (like databases or payment processors) as separate components that your app connects to. 5. Build, Release, Run: Make a clear distinction between preparing your app, releasing it, and running it in production. 6. Processes: Design your app so that each part doesn't rely on a specific computer or memory. It's like making LEGO blocks that fit together. 7. Port Binding: Let your app be accessible through a network port, and make sure it doesn't store critical information on a single computer. 8. Concurrency: Make your app able to handle more work by adding more copies of the same thing, like hiring more workers for a busy restaurant. 9. Disposability: Your app should start quickly and shut down gracefully, like turning off a light switch instead of yanking out the power cord. 10. Dev/Prod Parity: Ensure that what you use for developing your app is very similar to what you use in production, to avoid surprises. 11. Logs: Keep a record of what happens in your app so you can understand and fix issues, like a diary for your software. 12. Admin Processes: Run special tasks separately from your app, like doing maintenance work in a workshop instead of on the factory floor. Over to you: Where do you think these principles can have the most impact in improving software development practices? -- Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq hashtag #systemdesign hashtag #coding hashtag #interviewtips
Have you heard of the 12-Factor App? The "12 Factor App" offers a set of best practices for building modern software applications. Following these 12 principles can help developers and teams in building reliable, scalable, and manageable applications. Here's a brief overview of each principle: 1. Codebase: Have one place to keep all your code, and manage it using version control like Git. 2. Dependencies: List all the things your app needs to work properly, and make sure they're easy to install. 3. Config: Keep important settings like database credentials separate from your code, so you can change them without rewriting code. 4. Backing Services: Use other services (like databases or payment processors) as separate components that your app connects to. 5. Build, Release, Run: Make a clear distinction between preparing your app, releasing it, and running it in production. 6. Processes: Design your app so that each part doesn't rely on a specific computer or memory. It's like making LEGO blocks that fit together. 7. Port Binding: Let your app be accessible through a network port, and make sure it doesn't store critical information on a single computer. 8. Concurrency: Make your app able to handle more work by adding more copies of the same thing, like hiring more workers for a busy restaurant. 9. Disposability: Your app should start quickly and shut down gracefully, like turning off a light switch instead of yanking out the power cord. 10. Dev/Prod Parity: Ensure that what you use for developing your app is very similar to what you use in production, to avoid surprises. 11. Logs: Keep a record of what happens in your app so you can understand and fix issues, like a diary for your software. 12. Admin Processes: Run special tasks separately from your app, like doing maintenance work in a workshop instead of on the factory floor. Over to you: Where do you think these principles can have the most impact in improving software development practices? -- Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq #systemdesign #coding #interviewtips .
-
